openstack/heat
Code Issues Proposed changes

Merge "Add _() to fix i18N compliance (part 2)"

Browse Source
This commit is contained in:
Jenkins 2013-11-18 07:03:03 +00:00 committed by Gerrit Code Review
commit 186b5a471b
21 changed files with 232 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
heat/engine/api.py
View File

@ -17,6 +17,7 @@ from heat.openstack.common import timeutils
from heat.engine import template
from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__)
@ -31,7 +32,7 @@ def extract_args(params):
try:
timeout_mins = int(params.get(api.PARAM_TIMEOUT, 0))
except (ValueError, TypeError):
logger.exception('create timeout conversion')
logger.exception(_('create timeout conversion'))
else:
if timeout_mins > 0:
kwargs[api.PARAM_TIMEOUT] = timeout_mins
@ -205,7 +206,7 @@ def format_watch_data(wd):
if len(metric) == 1:
metric_name, metric_data = metric[0]
else:
logger.error("Unexpected number of keys in watch_data.data!")
logger.error(_("Unexpected number of keys in watch_data.data!"))
return
result = {

19
heat/engine/clients.py
View File

@ -17,6 +17,7 @@ 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__)
@ -28,23 +29,23 @@ try:
from swiftclient import client as swiftclient
except ImportError:
swiftclient = None
logger.info('swiftclient not available')
logger.info(_('swiftclient not available'))
try:
from neutronclient.v2_0 import client as neutronclient
except ImportError:
neutronclient = None
logger.info('neutronclient not available')
logger.info(_('neutronclient not available'))
try:
from cinderclient import client as cinderclient
except ImportError:
cinderclient = None
logger.info('cinderclient not available')
logger.info(_('cinderclient not available'))
try:
from ceilometerclient.v2 import client as ceilometerclient
except ImportError:
ceilometerclient = None
logger.info('ceilometerclient not available')
logger.info(_('ceilometerclient not available'))
_default_backend = "heat.engine.clients.OpenStackClients"
@ -91,7 +92,7 @@ class OpenStackClients(object):
con = self.context
if self.auth_token is None:
logger.error("Nova connection failed, no auth_token!")
logger.error(_("Nova connection failed, no auth_token!"))
return None
computeshell = novashell.OpenStackComputeShell()
@ -123,7 +124,7 @@ class OpenStackClients(object):
con = self.context
if self.auth_token is None:
logger.error("Swift connection failed, no auth_token!")
logger.error(_("Swift connection failed, no auth_token!"))
return None
args = {
@ -146,7 +147,7 @@ class OpenStackClients(object):
con = self.context
if self.auth_token is None:
logger.error("Neutron connection failed, no auth_token!")
logger.error(_("Neutron connection failed, no auth_token!"))
return None
args = {
@ -168,7 +169,7 @@ class OpenStackClients(object):
con = self.context
if self.auth_token is None:
logger.error("Cinder connection failed, no auth_token!")
logger.error(_("Cinder connection failed, no auth_token!"))
return None
args = {
@ -193,7 +194,7 @@ class OpenStackClients(object):
return self._ceilometer
if self.auth_token is None:
logger.error("Ceilometer connection failed, no auth_token!")
logger.error(_("Ceilometer connection failed, no auth_token!"))
return None
con = self.context
args = {

3
heat/engine/environment.py
View File

@ -16,6 +16,7 @@
import itertools
from heat.openstack.common import log
from heat.openstack.common.gettextutils import _
from heat.common import exception
@ -275,7 +276,7 @@ class ResourceRegistry(object):
info = self.get_resource_info(resource_type,
resource_name=resource_name)
if info is None:
msg = "Unknown resource Type : %s" % resource_type
msg = _("Unknown resource Type : %s") % resource_type
raise exception.StackValidationFailed(message=msg)
return info.get_class()

5
heat/engine/event.py
View File

@ -17,6 +17,7 @@ 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__)
@ -55,7 +56,7 @@ class Event(object):
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)
message = _('No event exists with id "%s"') % str(event_id)
raise exception.NotFound(message)
st = stack if stack is not None else\
@ -83,7 +84,7 @@ class Event(object):
ev['created_at'] = self.timestamp
if self.id is not None:
logger.warning('Duplicating event')
logger.warning(_('Duplicating event'))
new_ev = db_api.event_create(self.context, ev)
self.id = new_ev.id

20
heat/engine/parser.py
View File

@ -161,7 +161,7 @@ class Stack(collections.Mapping):
try:
stack_arn = self.identifier().arn()
except (AttributeError, ValueError, TypeError):
logger.warning("Unable to set parameters StackId identifier")
logger.warning(_("Unable to set parameters StackId identifier"))
else:
self.parameters.set_stack_id(stack_arn)
@ -306,7 +306,7 @@ class Stack(collections.Mapping):
dup_names = set(self.parameters.keys()) & set(self.keys())
if dup_names:
logger.debug("Duplicate names %s" % dup_names)
logger.debug(_("Duplicate names %s") % dup_names)
raise StackValidationFailed(message=_("Duplicate names %s") %
dup_names)
@ -427,13 +427,13 @@ class Stack(collections.Mapping):
s = db_api.stack_get_by_name(self.context, self._backup_name(),
owner_id=self.id)
if s is not None:
logger.debug('Loaded existing backup stack')
logger.debug(_('Loaded existing backup stack'))
return self.load(self.context, stack=s)
elif create_if_missing:
prev = type(self)(self.context, self.name, self.t, self.env,
owner_id=self.id)
prev.store(backup=True)
logger.debug('Created new backup stack')
logger.debug(_('Created new backup stack'))
return prev
else:
return None
@ -456,7 +456,7 @@ class Stack(collections.Mapping):
@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)
logger.error(_("Unexpected action %s passed to update!") % action)
self.state_set(self.UPDATE, self.FAILED,
"Invalid action %s" % action)
return
@ -464,7 +464,7 @@ class Stack(collections.Mapping):
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)
logger.debug(_("Starting update rollback for %s") % self.name)
else:
self.state_set(action, self.FAILED,
'State invalid for %s' % action)
@ -512,7 +512,7 @@ class Stack(collections.Mapping):
yield self.update_task(oldstack, action=self.ROLLBACK)
return
else:
logger.debug('Deleting backup stack')
logger.debug(_('Deleting backup stack'))
backup_stack.delete()
self.state_set(action, stack_status, reason)
@ -535,7 +535,7 @@ class Stack(collections.Mapping):
differently.
'''
if action not in (self.DELETE, self.ROLLBACK):
logger.error("Unexpected action %s passed to delete!" % action)
logger.error(_("Unexpected action %s passed to delete!") % action)
self.state_set(self.DELETE, self.FAILED,
"Invalid action %s" % action)
return
@ -626,7 +626,7 @@ class Stack(collections.Mapping):
scheduler.TaskRunner(res.destroy)()
except exception.ResourceFailure as ex:
failed = True
logger.error('delete: %s' % str(ex))
logger.error(_('delete: %s') % str(ex))
for res in deps:
if not failed:
@ -634,7 +634,7 @@ class Stack(collections.Mapping):
res.state_reset()
scheduler.TaskRunner(res.create)()
except exception.ResourceFailure as ex:
logger.exception('create')
logger.exception(_('create'))
failed = True
else:
res.state_set(res.CREATE, res.FAILED,

54
heat/engine/resource.py
View File

@ -384,7 +384,7 @@ class Resource(object):
self.state_set(action, self.FAILED,
'%s aborted' % action)
except Exception:
logger.exception('Error marking resource as failed')
logger.exception(_('Error marking resource as failed'))
else:
self.state_set(action, self.COMPLETE)
@ -395,7 +395,7 @@ class Resource(object):
'''
action = self.CREATE
if (self.action, self.status) != (self.INIT, self.COMPLETE):
exc = exception.Error('State %s invalid for create'
exc = exception.Error(_('State %s invalid for create')
% str(self.state))
raise exception.ResourceFailure(exc, self, action)
@ -424,7 +424,7 @@ class Resource(object):
if (self.action, self.status) in ((self.CREATE, self.IN_PROGRESS),
(self.UPDATE, self.IN_PROGRESS)):
exc = Exception('Resource update already requested')
exc = Exception(_('Resource update already requested'))
raise exception.ResourceFailure(exc, self, action)
logger.info('updating %s' % str(self))
@ -445,7 +445,8 @@ class Resource(object):
while not self.check_update_complete(handle_data):
yield
except UpdateReplace:
logger.debug("Resource %s update requires replacement" % self.name)
logger.debug(_("Resource %s update requires replacement") %
self.name)
raise
except Exception as ex:
logger.exception('update %s : %s' % (str(self), str(ex)))
@ -465,11 +466,11 @@ class Resource(object):
# 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'
exc = exception.Error(_('State %s invalid for suspend')
% str(self.state))
raise exception.ResourceFailure(exc, self, action)
logger.info('suspending %s' % str(self))
logger.info(_('suspending %s') % str(self))
return self._do_action(action)
def resume(self):
@ -481,11 +482,11 @@ class Resource(object):
# 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'
exc = exception.Error(_('State %s invalid for resume')
% str(self.state))
raise exception.ResourceFailure(exc, self, action)
logger.info('resuming %s' % str(self))
logger.info(_('resuming %s') % str(self))
return self._do_action(action)
def physical_resource_name(self):
@ -525,7 +526,7 @@ class Resource(object):
return name[0:2] + '-' + name[-postfix_length:]
def validate(self):
logger.info('Validating %s' % str(self))
logger.info(_('Validating %s') % str(self))
self.validate_deletion_policy(self.t)
return self.properties.validate()
@ -534,11 +535,11 @@ class Resource(object):
def validate_deletion_policy(cls, template):
deletion_policy = template.get('DeletionPolicy', 'Delete')
if deletion_policy not in ('Delete', 'Retain', 'Snapshot'):
msg = 'Invalid DeletionPolicy %s' % 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'
msg = _('Snapshot DeletionPolicy not supported')
raise exception.StackValidationFailed(message=msg)
def delete(self):
@ -556,7 +557,7 @@ class Resource(object):
initial_state = self.state
logger.info('deleting %s' % str(self))
logger.info(_('deleting %s') % str(self))
try:
self.state_set(action, self.IN_PROGRESS)
@ -578,7 +579,7 @@ class Resource(object):
yield
except Exception as ex:
logger.exception('Delete %s', str(self))
logger.exception(_('Delete %s'), str(self))
failure = exception.ResourceFailure(ex, self, self.action)
self.state_set(action, self.FAILED, str(failure))
raise failure
@ -588,7 +589,8 @@ class Resource(object):
self.state_set(action, self.FAILED,
'Deletion aborted')
except Exception:
logger.exception('Error marking resource deletion failed')
logger.exception(_('Error marking resource deletion '
'failed'))
else:
self.state_set(action, self.COMPLETE)
@ -618,7 +620,7 @@ class Resource(object):
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))
logger.warn(_('db error %s') % str(ex))
def _store(self):
'''Create the resource in the database.'''
@ -639,7 +641,7 @@ class Resource(object):
self.stack.updated_time = datetime.utcnow()
except Exception as ex:
logger.error('DB error %s' % str(ex))
logger.error(_('DB error %s') % str(ex))
def _add_event(self, action, status, reason):
'''Add a state change event to the database.'''
@ -650,7 +652,7 @@ class Resource(object):
try:
ev.store()
except Exception as ex:
logger.error('DB error %s' % str(ex))
logger.error(_('DB error %s') % str(ex))
def _store_or_update(self, action, status, reason):
self.action = action
@ -668,7 +670,7 @@ class Resource(object):
self.stack.updated_time = datetime.utcnow()
except Exception as ex:
logger.error('DB error %s' % str(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)
@ -696,10 +698,10 @@ class Resource(object):
def state_set(self, action, status, reason="state changed"):
if action not in self.ACTIONS:
raise ValueError("Invalid action %s" % action)
raise ValueError(_("Invalid action %s") % action)
if status not in self.STATUSES:
raise ValueError("Invalid status %s" % status)
raise ValueError(_("Invalid status %s") % status)
old_state = (self.action, self.status)
new_state = (action, status)
@ -766,17 +768,19 @@ class Resource(object):
try:
if self.action in (self.SUSPEND, self.DELETE):
msg = 'Cannot signal resource during %s' % self.action
msg = _('Cannot signal resource during %s') % self.action
raise Exception(msg)
if not callable(getattr(self, 'handle_signal', None)):
msg = 'Resource %s is not able to receive a signal' % str(self)
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 %s : %s' % (str(self), str(ex)))
logger.exception(_('signal %(name)s : %(msg)s') %
{'name': str(self), 'msg': str(ex)})
failure = exception.ResourceFailure(ex, self)
raise failure
@ -788,8 +792,8 @@ class Resource(object):
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)
logger.warning(_("Resource %s does not implement metadata update")
% self.name)
@classmethod
def resource_to_template(cls, resource_type):

9
heat/engine/resources/s3.py
View File

@ -84,8 +84,9 @@ class S3Bucket(resource.Resource):
"""Create a bucket."""
container = self.physical_resource_name()
headers = self.tags_to_headers()
logger.debug('S3Bucket create container %s with headers %s' %
(container, headers))
logger.debug(_('S3Bucket create container %(container)s with headers '
'%(headers)s') % {
'container': container, 'headers': headers})
if self.properties['WebsiteConfiguration'] is not None:
sc = self.properties['WebsiteConfiguration']
# we will assume that swift is configured for the staticweb
@ -113,12 +114,12 @@ class S3Bucket(resource.Resource):
def handle_delete(self):
"""Perform specified delete policy."""
logger.debug('S3Bucket delete container %s' % self.resource_id)
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))
logger.warn(_("Delete container failed: %s") % str(ex))
def FnGetRefId(self):
return unicode(self.resource_id)

9
heat/engine/resources/server.py
View File

@ -493,7 +493,7 @@ class Server(resource.Resource):
raise exception.NotFound(_('Failed to find server %s') %
self.resource_id)
else:
logger.debug('suspending server %s' % self.resource_id)
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)
@ -510,8 +510,9 @@ class Server(resource.Resource):
return True
server.get()
logger.debug('%s check_suspend_complete status = %s' %
(self.name, server.status))
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'
@ -538,7 +539,7 @@ class Server(resource.Resource):
raise exception.NotFound(_('Failed to find server %s') %
self.resource_id)
else:
logger.debug('resuming server %s' % self.resource_id)
logger.debug(_('resuming server %s') % self.resource_id)
server.resume()
return server

12
heat/engine/resources/stack.py
View File

@ -60,8 +60,10 @@ class NestedStack(stack_resource.StackResource):
try:
template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL])
except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" %
(self.properties[PROP_TEMPLATE_URL], str(r_exc)))
raise ValueError(_("Could not fetch remote template '%(url)s': "
"%(exc)s") %
{'url': self.properties[PROP_TEMPLATE_URL],
'exc': str(r_exc)})
template = template_format.parse(template_data)
@ -91,8 +93,10 @@ class NestedStack(stack_resource.StackResource):
try:
template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL])
except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" %
(self.properties[PROP_TEMPLATE_URL], str(r_exc)))
raise ValueError(_("Could not fetch remote template '%(url)s': "
"%(exc)s") %
{'url': self.properties[PROP_TEMPLATE_URL],
'exc': str(r_exc)})
template = template_format.parse(template_data)

12
heat/engine/resources/swift.py
View File

@ -90,20 +90,22 @@ class SwiftContainer(resource.Resource):
headers['X-Container-Read'] = self.properties['X-Container-Read']
if 'X-Container-Write' in self.properties.keys():
headers['X-Container-Write'] = self.properties['X-Container-Write']
logger.debug('SwiftContainer create container %s with headers %s' %
(container, headers))
logger.debug(_('SwiftContainer create container %(container)s with '
'headers %(headers)s') % {
'container': container, 'headers': headers})
self.swift().put_container(container, headers)
self.resource_id_set(container)
def handle_delete(self):
"""Perform specified delete policy."""
logger.debug('SwiftContainer delete container %s' % self.resource_id)
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))
logger.warn(_("Delete container failed: %s") % str(ex))
def FnGetRefId(self):
return unicode(self.resource_id)
@ -123,7 +125,7 @@ class SwiftContainer(resource.Resource):
try:
headers = self.swift().head_container(self.resource_id)
except clients.swiftclient.ClientException as ex:
logger.warn("Head container failed: %s" % str(ex))
logger.warn(_("Head container failed: %s") % str(ex))
return None
else:
if key == 'ObjectCount':

27
heat/engine/resources/template_resource.py
View File

@ -115,8 +115,10 @@ class TemplateResource(stack_resource.StackResource):
t_data = urlfetch.get(self.template_name,
allowed_schemes=self.allowed_schemes)
except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" %
(self.template_name, str(r_exc)))
raise ValueError(_("Could not fetch remote template "
"'%(name)s': %(exc)s") % {
'name': self.template_name,
'exc': str(r_exc)})
else:
# TODO(Randall) Whoops, misunderstanding on my part; this
# doesn't actually persist to the db like I thought.
@ -129,30 +131,33 @@ class TemplateResource(stack_resource.StackResource):
for n, fs in facade_schemata.items():
if fs.required and n not in self.properties_schema:
msg = ("Required property %s for facade %s "
"missing in provider") % (n, self.type())
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 %s type mismatch between facade %s (%s) "
"and provider (%s)") % (n, self.type(),
fs.type, ps.type)
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 %s "
"unknown in facade %s") % (n, self.type())
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 %s for facade %s "
"missing in provider") % (attr, self.type())
msg = (_("Attribute %(attr)s for facade %(type)s "
"missing in provider") % {
'attr': attr, 'type': self.type()})
raise exception.StackValidationFailed(message=msg)
def validate(self):

51
heat/engine/resources/user.py
View File

@ -55,19 +55,20 @@ class User(resource.Resource):
# 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, " % policy
+ "must be string resource name")
logger.warning(_("Ignoring policy %s, must be string "
"resource name") % policy)
continue
try:
policy_rsrc = self.stack[policy]
except KeyError:
logger.error("Policy %s does not exist in stack %s" %
(policy, self.stack.name))
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" %
logger.error(_("Policy %s is not an AccessPolicy resource") %
policy)
return False
@ -90,7 +91,8 @@ class User(resource.Resource):
def handle_delete(self):
if self.resource_id is None:
logger.error("Cannot delete User resource before user created!")
logger.error(_("Cannot delete User resource before user "
"created!"))
return
try:
self.keystone().delete_stack_user(self.resource_id)
@ -99,13 +101,15 @@ class User(resource.Resource):
def handle_suspend(self):
if self.resource_id is None:
logger.error("Cannot suspend User resource before user created!")
logger.error(_("Cannot suspend User resource before user "
"created!"))
return
self.keystone().disable_stack_user(self.resource_id)
def handle_resume(self):
if self.resource_id is None:
logger.error("Cannot resume User resource before user created!")
logger.error(_("Cannot resume User resource before user "
"created!"))
return
self.keystone().enable_stack_user(self.resource_id)
@ -121,8 +125,8 @@ class User(resource.Resource):
policies = (self.properties['Policies'] or [])
for policy in policies:
if not isinstance(policy, basestring):
logger.warning("Ignoring policy %s, " % policy
+ "must be string resource name")
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):
@ -168,12 +172,12 @@ class AccessKey(resource.Resource):
def handle_create(self):
user = self._get_user()
if user is None:
raise exception.NotFound('could not find user %s' %
raise exception.NotFound(_('could not find user %s') %
self.properties['UserName'])
kp = self.keystone().get_ec2_keypair(user.resource_id)
if not kp:
raise exception.Error("Error creating ec2 keypair for user %s" %
raise exception.Error(_("Error creating ec2 keypair for user %s") %
user)
self.resource_id_set(kp.access)
@ -186,7 +190,7 @@ class AccessKey(resource.Resource):
user = self._get_user()
if user is None:
logger.warning('Error deleting %s - user not found' % str(self))
logger.warning(_('Error deleting %s - user not found') % str(self))
return
user_id = user.resource_id
if user_id:
@ -203,23 +207,26 @@ class AccessKey(resource.Resource):
'''
if self._secret is None:
if not self.resource_id:
logger.warn('could not get secret for %s Error:%s' %
(self.properties['UserName'],
"resource_id not yet set"))
logger.warn(_('could not get secret for %(username)s '
'Error:%(msg)s') % {
'username': self.properties['UserName'],
'msg': "resource_id not yet set"})
else:
try:
user_id = self._get_user().resource_id
kp = self.keystone().get_ec2_keypair(user_id)
except Exception as ex:
logger.warn('could not get secret for %s Error:%s' %
(self.properties['UserName'],
str(ex)))
logger.warn(_('could not get secret for %(username)s '
'Error:%(msg)s') % {
'username': self.properties['UserName'],
'msg': str(ex)})
else:
if kp.access == self.resource_id:
self._secret = kp.secret
else:
msg = ("Unexpected ec2 keypair, for %s access %s" %
(user_id, kp.access))
msg = (_("Unexpected ec2 keypair, for %(id)s access "
"%(access)s") % {
'id': user_id, 'access': kp.access})
logger.error(msg)
return self._secret or '000-000-000'
@ -258,7 +265,7 @@ class AccessPolicy(resource.Resource):
# All of the provided resource names must exist in this stack
for resource in resources:
if resource not in self.stack:
logger.error("AccessPolicy resource %s not in stack" %
logger.error(_("AccessPolicy resource %s not in stack") %
resource)
raise exception.ResourceNotFound(resource_name=resource,
stack_name=self.stack.name)

18
heat/engine/resources/volume.py
View File

@ -128,8 +128,8 @@ class Volume(resource.Resource):
vol.get()
if vol.status == 'in-use':
logger.warn('cant delete volume when in-use')
raise exception.Error('Volume in use')
logger.warn(_('cant delete volume when in-use'))
raise exception.Error(_('Volume in use'))
vol.delete()
while True:
@ -196,14 +196,15 @@ class VolumeAttachTask(object):
vol = self.clients.cinder().volumes.get(self.volume_id)
while vol.status == 'available' or vol.status == 'attaching':
logger.debug('%s - volume status: %s' % (str(self), vol.status))
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))
logger.info(_('%s - complete') % str(self))
class VolumeDetachTask(object):
@ -236,7 +237,7 @@ class VolumeDetachTask(object):
try:
vol = self.clients.cinder().volumes.get(self.volume_id)
except clients.cinderclient.exceptions.NotFound:
logger.warning('%s - volume not found' % str(self))
logger.warning(_('%s - volume not found') % str(self))
return
server_api = self.clients.nova().volumes
@ -252,7 +253,7 @@ class VolumeDetachTask(object):
try:
vol.get()
while vol.status in ('in-use', 'detaching'):
logger.debug('%s - volume still in use' % str(self))
logger.debug(_('%s - volume still in use') % str(self))
yield
try:
@ -263,12 +264,13 @@ class VolumeDetachTask(object):
pass
vol.get()
logger.info('%s - status: %s' % (str(self), vol.status))
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))
logger.warning(_('%s - volume not found') % str(self))
class VolumeAttachment(resource.Resource):

29
heat/engine/resources/wait_condition.py
View File

@ -71,8 +71,8 @@ class WaitConditionHandle(signal_responder.SignalResponder):
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'])
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]
@ -81,8 +81,8 @@ class WaitConditionHandle(signal_responder.SignalResponder):
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")
logger.error(_("Metadata failed validation for %s") % self.name)
raise ValueError(_("Metadata format invalid"))
def get_status(self):
'''
@ -120,7 +120,8 @@ class WaitConditionFailure(Exception):
class WaitConditionTimeout(Exception):
def __init__(self, wait_condition, handle):
reasons = handle.get_status_reason(STATUS_SUCCESS)
message = '%d of %d received' % (len(reasons), wait_condition.count)
message = (_('%(len)d of %(count)d received') % {
'len': len(reasons), 'count': wait_condition.count})
if reasons:
message += ' - %s' % reasons
@ -158,20 +159,20 @@ class WaitCondition(resource.Resource):
handle_url = self.properties['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" %
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" %
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" %
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" %
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" %
raise ValueError(_("WaitCondition invalid Handle %s") %
handle_id.resource_name)
def _get_handle_resource_name(self):
@ -185,18 +186,20 @@ class WaitCondition(resource.Resource):
yield
except scheduler.Timeout:
timeout = WaitConditionTimeout(self, handle)
logger.info('%s Timed out (%s)' % (str(self), str(timeout)))
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('%s Failed (%s)' % (str(self), str(failure)))
logger.info(_('%(name)s Failed (%(failure)s)') % {
'name': str(self), 'failure': str(failure)})
raise failure
if len(handle_status) >= self.count:
logger.info("%s Succeeded" % str(self))
logger.info(_("%s Succeeded") % str(self))
return
def handle_create(self):

14
heat/engine/scheduler.py
View File

@ -105,7 +105,7 @@ class TaskRunner(object):
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))
logger.debug(_('%s sleeping') % str(self))
eventlet.sleep(wait_time)
def __call__(self, wait_time=1, timeout=None):
@ -128,7 +128,7 @@ class TaskRunner(object):
"""
assert self._runner is None, "Task already started"
logger.debug('%s starting' % str(self))
logger.debug(_('%s starting') % str(self))
if timeout is not None:
self._timeout = Timeout(self, timeout)
@ -140,7 +140,7 @@ class TaskRunner(object):
else:
self._runner = False
self._done = True
logger.debug('%s done (not resumable)' % str(self))
logger.debug(_('%s done (not resumable)') % str(self))
def step(self):
"""
@ -151,7 +151,7 @@ class TaskRunner(object):
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))
logger.info(_('%s timed out') % str(self))
try:
self._runner.throw(self._timeout)
@ -161,13 +161,13 @@ class TaskRunner(object):
# Clean up in case task swallows exception without exiting
self.cancel()
else:
logger.debug('%s running' % str(self))
logger.debug(_('%s running') % str(self))
try:
next(self._runner)
except StopIteration:
self._done = True
logger.debug('%s complete' % str(self))
logger.debug(_('%s complete') % str(self))
return self._done
@ -184,7 +184,7 @@ class TaskRunner(object):
def cancel(self):
"""Cancel the task if it is running."""
if self.started() and not self.done():
logger.debug('%s cancelled' % str(self))
logger.debug(_('%s cancelled') % str(self))
self._runner.close()
self._done = True

38
heat/engine/service.py
View File

@ -246,7 +246,7 @@ class EngineService(service.Service):
:param files: Files referenced from the template
:param args: Request parameters/args passed from API
"""
logger.info('template is %s' % template)
logger.info(_('template is %s') % template)
def _stack_create(stack):
# Create the stack, and create the periodic task if successful
@ -255,7 +255,8 @@ class EngineService(service.Service):
# Schedule a periodic watcher task for this stack
self._start_watch_task(stack.id, cnxt)
else:
logger.warning("Stack create failed, status %s" % stack.status)
logger.warning(_("Stack create failed, status %s") %
stack.status)
if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name)
@ -301,7 +302,7 @@ class EngineService(service.Service):
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
logger.info(_('template is %s') % template)
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
@ -345,7 +346,7 @@ class EngineService(service.Service):
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
"""
logger.info('validate_template')
logger.info(_('validate_template'))
if template is None:
msg = _("No Template provided.")
return webob.exc.HTTPBadRequest(explanation=msg)
@ -425,7 +426,7 @@ class EngineService(service.Service):
"""
st = self._get_stack(cnxt, stack_identity)
logger.info('deleting stack %s' % st.name)
logger.info(_('deleting stack %s') % st.name)
stack = parser.Stack.load(cnxt, stack=st)
@ -530,7 +531,7 @@ class EngineService(service.Service):
try:
akey_rsrc = self.find_physical_resource(cnxt, access_key)
except exception.PhysicalResourceNotFound:
logger.warning("access_key % not found!" % access_key)
logger.warning(_("access_key % not found!") % access_key)
return False
akey_rsrc_id = identifier.ResourceIdentifier(**akey_rsrc)
@ -540,9 +541,9 @@ class EngineService(service.Service):
ak_akey_rsrc = stack[akey_rsrc_id.resource_name]
return ak_akey_rsrc.access_allowed(resource_name)
else:
logger.warning("Cannot access resource from wrong stack!")
logger.warning(_("Cannot access resource from wrong stack!"))
else:
logger.warning("Cannot access resource, invalid credentials!")
logger.warning(_("Cannot access resource, invalid credentials!"))
return False
@ -553,7 +554,8 @@ class EngineService(service.Service):
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)
logger.warning(_("Access denied to resource %s")
% resource_name)
raise exception.Forbidden()
if resource_name not in stack:
@ -632,7 +634,7 @@ class EngineService(service.Service):
Handle request to perform suspend action on a stack
'''
def _stack_suspend(stack):
logger.debug("suspending stack %s" % stack.name)
logger.debug(_("suspending stack %s") % stack.name)
stack.suspend()
s = self._get_stack(cnxt, stack_identity)
@ -646,7 +648,7 @@ class EngineService(service.Service):
Handle request to perform a resume action on a stack
'''
def _stack_resume(stack):
logger.debug("resuming stack %s" % stack.name)
logger.debug(_("resuming stack %s") % stack.name)
stack.resume()
s = self._get_stack(cnxt, stack_identity)
@ -700,11 +702,11 @@ class EngineService(service.Service):
# 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)
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" %
logger.error(_("Unable to retrieve stack %s for periodic task") %
sid)
return
stack_context = self._load_user_creds(stack.user_creds_id)
@ -718,8 +720,8 @@ class EngineService(service.Service):
try:
wrs = db_api.watch_rule_get_all_by_stack(stack_context, sid)
except Exception as ex:
logger.warn('periodic_task db error (%s) %s' %
('watch rule removed?', str(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):
@ -784,7 +786,7 @@ class EngineService(service.Service):
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))
logger.warn(_('show_watch (all) db error %s') % str(ex))
return
wrs = [watchrule.WatchRule.load(cnxt, w) for w in wrn]
@ -804,13 +806,13 @@ class EngineService(service.Service):
# 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")
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))
logger.warn(_('show_metric (all) db error %s') % str(ex))
return
result = [api.format_watch_data(w) for w in wds]

3
heat/engine/signal_responder.py
View File

@ -26,6 +26,7 @@ from heat.engine import clients
from heat.engine import resource
from heat.openstack.common import log
from heat.openstack.common.gettextutils import _
LOG = log.getLogger(__name__)
SIGNAL_TYPES = (
@ -49,7 +50,7 @@ class SignalResponder(resource.Resource):
self.physical_resource_name())
kp = self.keystone().get_ec2_keypair(user_id)
if not kp:
raise exception.Error("Error creating ec2 keypair for user %s" %
raise exception.Error(_("Error creating ec2 keypair for user %s") %
user_id)
else:
self.resource_id_set(user_id)

7
heat/engine/stack_resource.py
View File

@ -24,6 +24,7 @@ from heat.engine import scheduler
from heat.engine import template as tmpl
from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__)
@ -67,7 +68,7 @@ class StackResource(resource.Resource):
parent_resource=self)
if self._nested is None:
raise exception.NotFound('Nested stack not found in DB')
raise exception.NotFound(_('Nested stack not found in DB'))
return self._nested
@ -170,7 +171,7 @@ class StackResource(resource.Resource):
nested_stack = self.nested()
if nested_stack.state != (nested_stack.UPDATE,
nested_stack.COMPLETE):
raise exception.Error("Nested stack update failed: %s" %
raise exception.Error(_("Nested stack update failed: %s") %
nested_stack.status_reason)
return True
@ -181,7 +182,7 @@ class StackResource(resource.Resource):
try:
stack = self.nested()
except exception.NotFound:
logger.info("Stack not found to delete")
logger.info(_("Stack not found to delete"))
else:
if stack is not None:
delete_task = scheduler.TaskRunner(stack.delete)

16
heat/engine/update.py
View File

@ -20,6 +20,7 @@ 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__)
@ -77,7 +78,7 @@ class StackUpdate(object):
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)
logger.debug(_("Deleting backup resource %s") % prev_res.name)
yield prev_res.destroy()
@staticmethod
@ -101,17 +102,18 @@ class StackUpdate(object):
# 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)
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)
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)
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)
@ -131,8 +133,10 @@ class StackUpdate(object):
except resource.UpdateReplace:
pass
else:
logger.info("Resource %s for stack %s updated" %
(res_name, self.existing_stack.name))
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)

38
heat/engine/watchrule.py
View File

@ -17,6 +17,7 @@
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
@ -75,8 +76,9 @@ class WatchRule(object):
try:
watch = db_api.watch_rule_get_by_name(context, watch_name)
except Exception as ex:
logger.warn('WatchRule.load (%s) db error %s' %
(watch_name, str(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:
@ -209,7 +211,7 @@ class WatchRule(object):
data = 0
for d in self.watch_data:
if d.created_at < self.now - self.timeperiod:
logger.debug('ignoring %s' % str(d.data))
logger.debug(_('ignoring %s') % str(d.data))
continue
data = data + float(d.data[self.rule['MetricName']]['Value'])
@ -250,7 +252,7 @@ class WatchRule(object):
self.stack_id, self.name, new_state)
actions = []
if self.ACTION_MAP[new_state] not in self.rule:
logger.info('no action for new state %s',
logger.info(_('no action for new state %s'),
new_state)
else:
s = db_api.stack_get(self.context, self.stack_id)
@ -260,8 +262,8 @@ class WatchRule(object):
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)
logger.warning(_("Could not process watch state %s for stack")
% new_state)
return actions
def _to_ceilometer(self, data):
@ -281,7 +283,8 @@ class WatchRule(object):
dims = dims[0]
sample['resource_metadata'] = dims
sample['resource_id'] = dims.get('InstanceId')
logger.debug('new sample:%s data:%s' % (k, sample))
logger.debug(_('new sample:%(k)s data:%(sample)s') % {
'k': k, 'sample': sample})
clients.ceilometer().samples.create(**sample)
def create_watch_data(self, data):
@ -293,7 +296,7 @@ class WatchRule(object):
return
if self.state == self.SUSPENDED:
logger.debug('Ignoring metric data for %s, SUSPENDED state'
logger.debug(_('Ignoring metric data for %s, SUSPENDED state')
% self.name)
return []
@ -303,8 +306,9 @@ class WatchRule(object):
# 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 %s) : %s' %
(self.rule['MetricName'], data))
logger.debug(_('Ignoring metric data (only accept %(metric)s) '
': %(data)s') % {
'metric': self.rule['MetricName'], 'data': data})
return
watch_data = {
@ -312,7 +316,8 @@ class WatchRule(object):
'watch_rule_id': self.id
}
wd = db_api.watch_data_create(None, watch_data)
logger.debug('new watch:%s data:%s' % (self.name, str(wd.data)))
logger.debug(_('new watch:%(name)s data:%(data)s')
% {'name': self.name, 'data': str(wd.data)})
def state_set(self, state):
'''
@ -337,11 +342,14 @@ class WatchRule(object):
if state != self.state:
actions = self.rule_actions(state)
if actions:
logger.debug("Overriding state %s for watch %s with %s" %
(self.state, self.name, state))
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 %s for watch %s" %
(self.state, self.name))
logger.warning(_("Unable to override state %(state)s for "
"watch %(name)s") % {
'state': self.state, 'name': self.name})
return actions

20
heat/tests/generic_resource.py
View File

@ -16,6 +16,7 @@ from heat.engine import resource
from heat.engine import signal_responder
from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__)
@ -29,22 +30,27 @@ class GenericResource(resource.Resource):
'Foo': 'Another generic attribute'}
def handle_create(self):
logger.warning('Creating generic resource (Type "%s")' % self.type())
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())
logger.warning(_('Updating generic resource (Type "%s")') %
self.type())
def handle_delete(self):
logger.warning('Deleting generic resource (Type "%s")' % self.type())
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())
logger.warning(_('Suspending generic resource (Type "%s")') %
self.type())
def handle_resume(self):
logger.warning('Resuming generic resource (Type "%s")' % self.type())
logger.warning(_('Resuming generic resource (Type "%s")') %
self.type())
class ResourceWithProps(GenericResource):
@ -61,8 +67,8 @@ class SignalResource(signal_responder.SignalResponder):
attributes_schema = {'AlarmUrl': 'Get a signed webhook'}
def handle_signal(self, details=None):
logger.warning('Signaled resource (Type "%s") %s' % (self.type(),
details))
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: