openstack
/
heat
Code Issues Proposed changes

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

This commit is contained in:
Jenkins 2013-11-18 07:03:03 +00:00 committed by Gerrit Code Review
parent 62252bd586 bd72bf369c
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.engine import template
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -31,7 +32,7 @@ def extract_args(params):
try: try:
timeout_mins = int(params.get(api.PARAM_TIMEOUT, 0)) timeout_mins = int(params.get(api.PARAM_TIMEOUT, 0))
except (ValueError, TypeError): except (ValueError, TypeError):
logger.exception('create timeout conversion') logger.exception(_('create timeout conversion'))
else: else:
if timeout_mins > 0: if timeout_mins > 0:
kwargs[api.PARAM_TIMEOUT] = timeout_mins kwargs[api.PARAM_TIMEOUT] = timeout_mins
@ -205,7 +206,7 @@ def format_watch_data(wd):
if len(metric) == 1: if len(metric) == 1:
metric_name, metric_data = metric[0] metric_name, metric_data = metric[0]
else: else:
logger.error("Unexpected number of keys in watch_data.data!") logger.error(_("Unexpected number of keys in watch_data.data!"))
return return
result = { 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 importutils
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -28,23 +29,23 @@ try:
from swiftclient import client as swiftclient from swiftclient import client as swiftclient
except ImportError: except ImportError:
swiftclient = None swiftclient = None
logger.info('swiftclient not available') logger.info(_('swiftclient not available'))
try: try:
from neutronclient.v2_0 import client as neutronclient from neutronclient.v2_0 import client as neutronclient
except ImportError: except ImportError:
neutronclient = None neutronclient = None
logger.info('neutronclient not available') logger.info(_('neutronclient not available'))
try: try:
from cinderclient import client as cinderclient from cinderclient import client as cinderclient
except ImportError: except ImportError:
cinderclient = None cinderclient = None
logger.info('cinderclient not available') logger.info(_('cinderclient not available'))
try: try:
from ceilometerclient.v2 import client as ceilometerclient from ceilometerclient.v2 import client as ceilometerclient
except ImportError: except ImportError:
ceilometerclient = None ceilometerclient = None
logger.info('ceilometerclient not available') logger.info(_('ceilometerclient not available'))
_default_backend = "heat.engine.clients.OpenStackClients" _default_backend = "heat.engine.clients.OpenStackClients"
@ -91,7 +92,7 @@ class OpenStackClients(object):
con = self.context con = self.context
if self.auth_token is None: if self.auth_token is None:
logger.error("Nova connection failed, no auth_token!") logger.error(_("Nova connection failed, no auth_token!"))
return None return None
computeshell = novashell.OpenStackComputeShell() computeshell = novashell.OpenStackComputeShell()
@ -123,7 +124,7 @@ class OpenStackClients(object):
con = self.context con = self.context
if self.auth_token is None: if self.auth_token is None:
logger.error("Swift connection failed, no auth_token!") logger.error(_("Swift connection failed, no auth_token!"))
return None return None
args = { args = {
@ -146,7 +147,7 @@ class OpenStackClients(object):
con = self.context con = self.context
if self.auth_token is None: if self.auth_token is None:
logger.error("Neutron connection failed, no auth_token!") logger.error(_("Neutron connection failed, no auth_token!"))
return None return None
args = { args = {
@ -168,7 +169,7 @@ class OpenStackClients(object):
con = self.context con = self.context
if self.auth_token is None: if self.auth_token is None:
logger.error("Cinder connection failed, no auth_token!") logger.error(_("Cinder connection failed, no auth_token!"))
return None return None
args = { args = {
@ -193,7 +194,7 @@ class OpenStackClients(object):
return self._ceilometer return self._ceilometer
if self.auth_token is None: if self.auth_token is None:
logger.error("Ceilometer connection failed, no auth_token!") logger.error(_("Ceilometer connection failed, no auth_token!"))
return None return None
con = self.context con = self.context
args = { args = {

3
heat/engine/environment.py
View File

@ -16,6 +16,7 @@
import itertools import itertools
from heat.openstack.common import log from heat.openstack.common import log
from heat.openstack.common.gettextutils import _
from heat.common import exception from heat.common import exception
@ -275,7 +276,7 @@ class ResourceRegistry(object):
info = self.get_resource_info(resource_type, info = self.get_resource_info(resource_type,
resource_name=resource_name) resource_name=resource_name)
if info is None: if info is None:
msg = "Unknown resource Type : %s" % resource_type msg = _("Unknown resource Type : %s") % resource_type
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
return info.get_class() 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 exception
from heat.common import identifier from heat.common import identifier
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -55,7 +56,7 @@ class Event(object):
ev = event if event is not None else\ ev = event if event is not None else\
db_api.event_get(context, event_id) db_api.event_get(context, event_id)
if ev is None: 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) raise exception.NotFound(message)
st = stack if stack is not None else\ st = stack if stack is not None else\
@ -83,7 +84,7 @@ class Event(object):
ev['created_at'] = self.timestamp ev['created_at'] = self.timestamp
if self.id is not None: if self.id is not None:
logger.warning('Duplicating event') logger.warning(_('Duplicating event'))
new_ev = db_api.event_create(self.context, ev) new_ev = db_api.event_create(self.context, ev)
self.id = new_ev.id self.id = new_ev.id

20
heat/engine/parser.py
View File

@ -161,7 +161,7 @@ class Stack(collections.Mapping):
try: try:
stack_arn = self.identifier().arn() stack_arn = self.identifier().arn()
except (AttributeError, ValueError, TypeError): except (AttributeError, ValueError, TypeError):
logger.warning("Unable to set parameters StackId identifier") logger.warning(_("Unable to set parameters StackId identifier"))
else: else:
self.parameters.set_stack_id(stack_arn) self.parameters.set_stack_id(stack_arn)
@ -306,7 +306,7 @@ class Stack(collections.Mapping):
dup_names = set(self.parameters.keys()) & set(self.keys()) dup_names = set(self.parameters.keys()) & set(self.keys())
if dup_names: if dup_names:
logger.debug("Duplicate names %s" % dup_names) logger.debug(_("Duplicate names %s") % dup_names)
raise StackValidationFailed(message=_("Duplicate names %s") % raise StackValidationFailed(message=_("Duplicate names %s") %
dup_names) dup_names)
@ -427,13 +427,13 @@ class Stack(collections.Mapping):
s = db_api.stack_get_by_name(self.context, self._backup_name(), s = db_api.stack_get_by_name(self.context, self._backup_name(),
owner_id=self.id) owner_id=self.id)
if s is not None: if s is not None:
logger.debug('Loaded existing backup stack') logger.debug(_('Loaded existing backup stack'))
return self.load(self.context, stack=s) return self.load(self.context, stack=s)
elif create_if_missing: elif create_if_missing:
prev = type(self)(self.context, self.name, self.t, self.env, prev = type(self)(self.context, self.name, self.t, self.env,
owner_id=self.id) owner_id=self.id)
prev.store(backup=True) prev.store(backup=True)
logger.debug('Created new backup stack') logger.debug(_('Created new backup stack'))
return prev return prev
else: else:
return None return None
@ -456,7 +456,7 @@ class Stack(collections.Mapping):
@scheduler.wrappertask @scheduler.wrappertask
def update_task(self, newstack, action=UPDATE): def update_task(self, newstack, action=UPDATE):
if action not in (self.UPDATE, self.ROLLBACK): 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, self.state_set(self.UPDATE, self.FAILED,
"Invalid action %s" % action) "Invalid action %s" % action)
return return
@ -464,7 +464,7 @@ class Stack(collections.Mapping):
if self.status != self.COMPLETE: if self.status != self.COMPLETE:
if (action == self.ROLLBACK and if (action == self.ROLLBACK and
self.state == (self.UPDATE, self.IN_PROGRESS)): 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: else:
self.state_set(action, self.FAILED, self.state_set(action, self.FAILED,
'State invalid for %s' % action) 'State invalid for %s' % action)
@ -512,7 +512,7 @@ class Stack(collections.Mapping):
yield self.update_task(oldstack, action=self.ROLLBACK) yield self.update_task(oldstack, action=self.ROLLBACK)
return return
else: else:
logger.debug('Deleting backup stack') logger.debug(_('Deleting backup stack'))
backup_stack.delete() backup_stack.delete()
self.state_set(action, stack_status, reason) self.state_set(action, stack_status, reason)
@ -535,7 +535,7 @@ class Stack(collections.Mapping):
differently. differently.
''' '''
if action not in (self.DELETE, self.ROLLBACK): 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, self.state_set(self.DELETE, self.FAILED,
"Invalid action %s" % action) "Invalid action %s" % action)
return return
@ -626,7 +626,7 @@ class Stack(collections.Mapping):
scheduler.TaskRunner(res.destroy)() scheduler.TaskRunner(res.destroy)()
except exception.ResourceFailure as ex: except exception.ResourceFailure as ex:
failed = True failed = True
logger.error('delete: %s' % str(ex)) logger.error(_('delete: %s') % str(ex))
for res in deps: for res in deps:
if not failed: if not failed:
@ -634,7 +634,7 @@ class Stack(collections.Mapping):
res.state_reset() res.state_reset()
scheduler.TaskRunner(res.create)() scheduler.TaskRunner(res.create)()
except exception.ResourceFailure as ex: except exception.ResourceFailure as ex:
logger.exception('create') logger.exception(_('create'))
failed = True failed = True
else: else:
res.state_set(res.CREATE, res.FAILED, 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, self.state_set(action, self.FAILED,
'%s aborted' % action) '%s aborted' % action)
except Exception: except Exception:
logger.exception('Error marking resource as failed') logger.exception(_('Error marking resource as failed'))
else: else:
self.state_set(action, self.COMPLETE) self.state_set(action, self.COMPLETE)
@ -395,7 +395,7 @@ class Resource(object):
''' '''
action = self.CREATE action = self.CREATE
if (self.action, self.status) != (self.INIT, self.COMPLETE): 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)) % str(self.state))
raise exception.ResourceFailure(exc, self, action) raise exception.ResourceFailure(exc, self, action)
@ -424,7 +424,7 @@ class Resource(object):
if (self.action, self.status) in ((self.CREATE, self.IN_PROGRESS), if (self.action, self.status) in ((self.CREATE, self.IN_PROGRESS),
(self.UPDATE, 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) raise exception.ResourceFailure(exc, self, action)
logger.info('updating %s' % str(self)) logger.info('updating %s' % str(self))
@ -445,7 +445,8 @@ class Resource(object):
while not self.check_update_complete(handle_data): while not self.check_update_complete(handle_data):
yield yield
except UpdateReplace: except UpdateReplace:
logger.debug("Resource %s update requires replacement" % self.name) logger.debug(_("Resource %s update requires replacement") %
self.name)
raise raise
except Exception as ex: except Exception as ex:
logger.exception('update %s : %s' % (str(self), str(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 # Don't try to suspend the resource unless it's in a stable state
if (self.action == self.DELETE or self.status != self.COMPLETE): 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)) % str(self.state))
raise exception.ResourceFailure(exc, self, action) raise exception.ResourceFailure(exc, self, action)
logger.info('suspending %s' % str(self)) logger.info(_('suspending %s') % str(self))
return self._do_action(action) return self._do_action(action)
def resume(self): def resume(self):
@ -481,11 +482,11 @@ class Resource(object):
# Can't resume a resource unless it's SUSPEND_COMPLETE # Can't resume a resource unless it's SUSPEND_COMPLETE
if self.state != (self.SUSPEND, self.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)) % str(self.state))
raise exception.ResourceFailure(exc, self, action) raise exception.ResourceFailure(exc, self, action)
logger.info('resuming %s' % str(self)) logger.info(_('resuming %s') % str(self))
return self._do_action(action) return self._do_action(action)
def physical_resource_name(self): def physical_resource_name(self):
@ -525,7 +526,7 @@ class Resource(object):
return name[0:2] + '-' + name[-postfix_length:] return name[0:2] + '-' + name[-postfix_length:]
def validate(self): def validate(self):
logger.info('Validating %s' % str(self)) logger.info(_('Validating %s') % str(self))
self.validate_deletion_policy(self.t) self.validate_deletion_policy(self.t)
return self.properties.validate() return self.properties.validate()
@ -534,11 +535,11 @@ class Resource(object):
def validate_deletion_policy(cls, template): def validate_deletion_policy(cls, template):
deletion_policy = template.get('DeletionPolicy', 'Delete') deletion_policy = template.get('DeletionPolicy', 'Delete')
if deletion_policy not in ('Delete', 'Retain', 'Snapshot'): 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) raise exception.StackValidationFailed(message=msg)
elif deletion_policy == 'Snapshot': elif deletion_policy == 'Snapshot':
if not callable(getattr(cls, 'handle_snapshot_delete', None)): if not callable(getattr(cls, 'handle_snapshot_delete', None)):
msg = 'Snapshot DeletionPolicy not supported' msg = _('Snapshot DeletionPolicy not supported')
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
def delete(self): def delete(self):
@ -556,7 +557,7 @@ class Resource(object):
initial_state = self.state initial_state = self.state
logger.info('deleting %s' % str(self)) logger.info(_('deleting %s') % str(self))
try: try:
self.state_set(action, self.IN_PROGRESS) self.state_set(action, self.IN_PROGRESS)
@ -578,7 +579,7 @@ class Resource(object):
yield yield
except Exception as ex: except Exception as ex:
logger.exception('Delete %s', str(self)) logger.exception(_('Delete %s'), str(self))
failure = exception.ResourceFailure(ex, self, self.action) failure = exception.ResourceFailure(ex, self, self.action)
self.state_set(action, self.FAILED, str(failure)) self.state_set(action, self.FAILED, str(failure))
raise failure raise failure
@ -588,7 +589,8 @@ class Resource(object):
self.state_set(action, self.FAILED, self.state_set(action, self.FAILED,
'Deletion aborted') 'Deletion aborted')
except Exception: except Exception:
logger.exception('Error marking resource deletion failed') logger.exception(_('Error marking resource deletion '
'failed'))
else: else:
self.state_set(action, self.COMPLETE) self.state_set(action, self.COMPLETE)
@ -618,7 +620,7 @@ class Resource(object):
rs = db_api.resource_get(self.context, self.id) rs = db_api.resource_get(self.context, self.id)
rs.update_and_save({'nova_instance': self.resource_id}) rs.update_and_save({'nova_instance': self.resource_id})
except Exception as ex: except Exception as ex:
logger.warn('db error %s' % str(ex)) logger.warn(_('db error %s') % str(ex))
def _store(self): def _store(self):
'''Create the resource in the database.''' '''Create the resource in the database.'''
@ -639,7 +641,7 @@ class Resource(object):
self.stack.updated_time = datetime.utcnow() self.stack.updated_time = datetime.utcnow()
except Exception as ex: 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): def _add_event(self, action, status, reason):
'''Add a state change event to the database.''' '''Add a state change event to the database.'''
@ -650,7 +652,7 @@ class Resource(object):
try: try:
ev.store() ev.store()
except Exception as ex: 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): def _store_or_update(self, action, status, reason):
self.action = action self.action = action
@ -668,7 +670,7 @@ class Resource(object):
self.stack.updated_time = datetime.utcnow() self.stack.updated_time = datetime.utcnow()
except Exception as ex: 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 # store resource in DB on transition to CREATE_IN_PROGRESS
# all other transistions (other than to DELETE_COMPLETE) # all other transistions (other than to DELETE_COMPLETE)
@ -696,10 +698,10 @@ class Resource(object):
def state_set(self, action, status, reason="state changed"): def state_set(self, action, status, reason="state changed"):
if action not in self.ACTIONS: if action not in self.ACTIONS:
raise ValueError("Invalid action %s" % action) raise ValueError(_("Invalid action %s") % action)
if status not in self.STATUSES: if status not in self.STATUSES:
raise ValueError("Invalid status %s" % status) raise ValueError(_("Invalid status %s") % status)
old_state = (self.action, self.status) old_state = (self.action, self.status)
new_state = (action, status) new_state = (action, status)
@ -766,17 +768,19 @@ class Resource(object):
try: try:
if self.action in (self.SUSPEND, self.DELETE): 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) raise Exception(msg)
if not callable(getattr(self, 'handle_signal', None)): 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) raise Exception(msg)
self._add_event('signal', self.status, get_string_details()) self._add_event('signal', self.status, get_string_details())
self.handle_signal(details) self.handle_signal(details)
except Exception as ex: 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) failure = exception.ResourceFailure(ex, self)
raise failure raise failure
@ -788,8 +792,8 @@ class Resource(object):
No-op for resources which don't explicitly override this method No-op for resources which don't explicitly override this method
''' '''
if new_metadata: if new_metadata:
logger.warning("Resource %s does not implement metadata update" % logger.warning(_("Resource %s does not implement metadata update")
self.name) % self.name)
@classmethod @classmethod
def resource_to_template(cls, resource_type): 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.""" """Create a bucket."""
container = self.physical_resource_name() container = self.physical_resource_name()
headers = self.tags_to_headers() headers = self.tags_to_headers()
logger.debug('S3Bucket create container %s with headers %s' % logger.debug(_('S3Bucket create container %(container)s with headers '
(container, headers)) '%(headers)s') % {
'container': container, 'headers': headers})
if self.properties['WebsiteConfiguration'] is not None: if self.properties['WebsiteConfiguration'] is not None:
sc = self.properties['WebsiteConfiguration'] sc = self.properties['WebsiteConfiguration']
# we will assume that swift is configured for the staticweb # we will assume that swift is configured for the staticweb
@ -113,12 +114,12 @@ class S3Bucket(resource.Resource):
def handle_delete(self): def handle_delete(self):
"""Perform specified delete policy.""" """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: if self.resource_id is not None:
try: try:
self.swift().delete_container(self.resource_id) self.swift().delete_container(self.resource_id)
except clients.swiftclient.ClientException as ex: 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): def FnGetRefId(self):
return unicode(self.resource_id) 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') % raise exception.NotFound(_('Failed to find server %s') %
self.resource_id) self.resource_id)
else: 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 # We want the server.suspend to happen after the volume
# detachement has finished, so pass both tasks and the server # detachement has finished, so pass both tasks and the server
suspend_runner = scheduler.TaskRunner(server.suspend) suspend_runner = scheduler.TaskRunner(server.suspend)
@ -510,8 +510,9 @@ class Server(resource.Resource):
return True return True
server.get() server.get()
logger.debug('%s check_suspend_complete status = %s' % logger.debug(_('%(name)s check_suspend_complete status '
(self.name, server.status)) '= %(status)s') % {
'name': self.name, 'status': server.status})
if server.status in list(nova_utils.deferred_server_statuses + if server.status in list(nova_utils.deferred_server_statuses +
['ACTIVE']): ['ACTIVE']):
return server.status == 'SUSPENDED' return server.status == 'SUSPENDED'
@ -538,7 +539,7 @@ class Server(resource.Resource):
raise exception.NotFound(_('Failed to find server %s') % raise exception.NotFound(_('Failed to find server %s') %
self.resource_id) self.resource_id)
else: else:
logger.debug('resuming server %s' % self.resource_id) logger.debug(_('resuming server %s') % self.resource_id)
server.resume() server.resume()
return server return server

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

@ -60,8 +60,10 @@ class NestedStack(stack_resource.StackResource):
try: try:
template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL]) template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL])
except (exceptions.RequestException, IOError) as r_exc: except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" % raise ValueError(_("Could not fetch remote template '%(url)s': "
(self.properties[PROP_TEMPLATE_URL], str(r_exc))) "%(exc)s") %
{'url': self.properties[PROP_TEMPLATE_URL],
'exc': str(r_exc)})
template = template_format.parse(template_data) template = template_format.parse(template_data)
@ -91,8 +93,10 @@ class NestedStack(stack_resource.StackResource):
try: try:
template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL]) template_data = urlfetch.get(self.properties[PROP_TEMPLATE_URL])
except (exceptions.RequestException, IOError) as r_exc: except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" % raise ValueError(_("Could not fetch remote template '%(url)s': "
(self.properties[PROP_TEMPLATE_URL], str(r_exc))) "%(exc)s") %
{'url': self.properties[PROP_TEMPLATE_URL],
'exc': str(r_exc)})
template = template_format.parse(template_data) 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'] headers['X-Container-Read'] = self.properties['X-Container-Read']
if 'X-Container-Write' in self.properties.keys(): if 'X-Container-Write' in self.properties.keys():
headers['X-Container-Write'] = self.properties['X-Container-Write'] headers['X-Container-Write'] = self.properties['X-Container-Write']
logger.debug('SwiftContainer create container %s with headers %s' % logger.debug(_('SwiftContainer create container %(container)s with '
(container, headers)) 'headers %(headers)s') % {
'container': container, 'headers': headers})
self.swift().put_container(container, headers) self.swift().put_container(container, headers)
self.resource_id_set(container) self.resource_id_set(container)
def handle_delete(self): def handle_delete(self):
"""Perform specified delete policy.""" """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: if self.resource_id is not None:
try: try:
self.swift().delete_container(self.resource_id) self.swift().delete_container(self.resource_id)
except clients.swiftclient.ClientException as ex: 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): def FnGetRefId(self):
return unicode(self.resource_id) return unicode(self.resource_id)
@ -123,7 +125,7 @@ class SwiftContainer(resource.Resource):
try: try:
headers = self.swift().head_container(self.resource_id) headers = self.swift().head_container(self.resource_id)
except clients.swiftclient.ClientException as ex: except clients.swiftclient.ClientException as ex:
logger.warn("Head container failed: %s" % str(ex)) logger.warn(_("Head container failed: %s") % str(ex))
return None return None
else: else:
if key == 'ObjectCount': 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, t_data = urlfetch.get(self.template_name,
allowed_schemes=self.allowed_schemes) allowed_schemes=self.allowed_schemes)
except (exceptions.RequestException, IOError) as r_exc: except (exceptions.RequestException, IOError) as r_exc:
raise ValueError("Could not fetch remote template '%s': %s" % raise ValueError(_("Could not fetch remote template "
(self.template_name, str(r_exc))) "'%(name)s': %(exc)s") % {
'name': self.template_name,
'exc': str(r_exc)})
else: else:
# TODO(Randall) Whoops, misunderstanding on my part; this # TODO(Randall) Whoops, misunderstanding on my part; this
# doesn't actually persist to the db like I thought. # 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(): for n, fs in facade_schemata.items():
if fs.required and n not in self.properties_schema: if fs.required and n not in self.properties_schema:
msg = ("Required property %s for facade %s " msg = (_("Required property %(n)s for facade %(type)s "
"missing in provider") % (n, self.type()) "missing in provider") % {'n': n, 'type': self.type()})
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
ps = self.properties_schema.get(n) ps = self.properties_schema.get(n)
if (n in self.properties_schema and if (n in self.properties_schema and
(fs.type != ps.type)): (fs.type != ps.type)):
# Type mismatch # Type mismatch
msg = ("Property %s type mismatch between facade %s (%s) " msg = (_("Property %(n)s type mismatch between facade %(type)s"
"and provider (%s)") % (n, self.type(), " (%(fs_type)s) and provider (%(ps_type)s)") % {
fs.type, ps.type) 'n': n, 'type': self.type(),
'fs_type': fs.type, 'ps_type': ps.type})
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
for n, ps in self.properties_schema.items(): for n, ps in self.properties_schema.items():
if ps.required and n not in facade_schemata: if ps.required and n not in facade_schemata:
# Required property for template not present in facade # Required property for template not present in facade
msg = ("Provider requires property %s " msg = (_("Provider requires property %(n)s "
"unknown in facade %s") % (n, self.type()) "unknown in facade %(type)s") % {
'n': n, 'type': self.type()})
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
for attr in facade_cls.attributes_schema: for attr in facade_cls.attributes_schema:
if attr not in self.attributes_schema: if attr not in self.attributes_schema:
msg = ("Attribute %s for facade %s " msg = (_("Attribute %(attr)s for facade %(type)s "
"missing in provider") % (attr, self.type()) "missing in provider") % {
'attr': attr, 'type': self.type()})
raise exception.StackValidationFailed(message=msg) raise exception.StackValidationFailed(message=msg)
def validate(self): 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 # ignore the policy (don't reject it because we previously ignored
# and we don't want to break templates which previously worked # and we don't want to break templates which previously worked
if not isinstance(policy, basestring): if not isinstance(policy, basestring):
logger.warning("Ignoring policy %s, " % policy logger.warning(_("Ignoring policy %s, must be string "
+ "must be string resource name") "resource name") % policy)
continue continue
try: try:
policy_rsrc = self.stack[policy] policy_rsrc = self.stack[policy]
except KeyError: except KeyError:
logger.error("Policy %s does not exist in stack %s" % logger.error(_("Policy %(policy)s does not exist in stack "
(policy, self.stack.name)) "%(stack)s") % {
'policy': policy, 'stack': self.stack.name})
return False return False
if not callable(getattr(policy_rsrc, 'access_allowed', None)): 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) policy)
return False return False
@ -90,7 +91,8 @@ class User(resource.Resource):
def handle_delete(self): def handle_delete(self):
if self.resource_id is None: 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 return
try: try:
self.keystone().delete_stack_user(self.resource_id) self.keystone().delete_stack_user(self.resource_id)
@ -99,13 +101,15 @@ class User(resource.Resource):
def handle_suspend(self): def handle_suspend(self):
if self.resource_id is None: 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 return
self.keystone().disable_stack_user(self.resource_id) self.keystone().disable_stack_user(self.resource_id)
def handle_resume(self): def handle_resume(self):
if self.resource_id is None: 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 return
self.keystone().enable_stack_user(self.resource_id) self.keystone().enable_stack_user(self.resource_id)
@ -121,8 +125,8 @@ class User(resource.Resource):
policies = (self.properties['Policies'] or []) policies = (self.properties['Policies'] or [])
for policy in policies: for policy in policies:
if not isinstance(policy, basestring): if not isinstance(policy, basestring):
logger.warning("Ignoring policy %s, " % policy logger.warning(_("Ignoring policy %s, must be string "
+ "must be string resource name") "resource name") % policy)
continue continue
policy_rsrc = self.stack[policy] policy_rsrc = self.stack[policy]
if not policy_rsrc.access_allowed(resource_name): if not policy_rsrc.access_allowed(resource_name):
@ -168,12 +172,12 @@ class AccessKey(resource.Resource):
def handle_create(self): def handle_create(self):
user = self._get_user() user = self._get_user()
if user is None: if user is None:
raise exception.NotFound('could not find user %s' % raise exception.NotFound(_('could not find user %s') %
self.properties['UserName']) self.properties['UserName'])
kp = self.keystone().get_ec2_keypair(user.resource_id) kp = self.keystone().get_ec2_keypair(user.resource_id)
if not kp: if not kp:
raise exception.Error("Error creating ec2 keypair for user %s" % raise exception.Error(_("Error creating ec2 keypair for user %s") %
user) user)
self.resource_id_set(kp.access) self.resource_id_set(kp.access)
@ -186,7 +190,7 @@ class AccessKey(resource.Resource):
user = self._get_user() user = self._get_user()
if user is None: 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 return
user_id = user.resource_id user_id = user.resource_id
if user_id: if user_id:
@ -203,23 +207,26 @@ class AccessKey(resource.Resource):
''' '''
if self._secret is None: if self._secret is None:
if not self.resource_id: if not self.resource_id:
logger.warn('could not get secret for %s Error:%s' % logger.warn(_('could not get secret for %(username)s '
(self.properties['UserName'], 'Error:%(msg)s') % {
"resource_id not yet set")) 'username': self.properties['UserName'],
'msg': "resource_id not yet set"})
else: else:
try: try:
user_id = self._get_user().resource_id user_id = self._get_user().resource_id
kp = self.keystone().get_ec2_keypair(user_id) kp = self.keystone().get_ec2_keypair(user_id)
except Exception as ex: except Exception as ex:
logger.warn('could not get secret for %s Error:%s' % logger.warn(_('could not get secret for %(username)s '
(self.properties['UserName'], 'Error:%(msg)s') % {
str(ex))) 'username': self.properties['UserName'],
'msg': str(ex)})
else: else:
if kp.access == self.resource_id: if kp.access == self.resource_id:
self._secret = kp.secret self._secret = kp.secret
else: else:
msg = ("Unexpected ec2 keypair, for %s access %s" % msg = (_("Unexpected ec2 keypair, for %(id)s access "
(user_id, kp.access)) "%(access)s") % {
'id': user_id, 'access': kp.access})
logger.error(msg) logger.error(msg)
return self._secret or '000-000-000' 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 # All of the provided resource names must exist in this stack
for resource in resources: for resource in resources:
if resource not in self.stack: if resource not in self.stack:
logger.error("AccessPolicy resource %s not in stack" % logger.error(_("AccessPolicy resource %s not in stack") %
resource) resource)
raise exception.ResourceNotFound(resource_name=resource, raise exception.ResourceNotFound(resource_name=resource,
stack_name=self.stack.name) stack_name=self.stack.name)

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

@ -128,8 +128,8 @@ class Volume(resource.Resource):
vol.get() vol.get()
if vol.status == 'in-use': if vol.status == 'in-use':
logger.warn('cant delete volume when in-use') logger.warn(_('cant delete volume when in-use'))
raise exception.Error('Volume in use') raise exception.Error(_('Volume in use'))
vol.delete() vol.delete()
while True: while True:
@ -196,14 +196,15 @@ class VolumeAttachTask(object):
vol = self.clients.cinder().volumes.get(self.volume_id) vol = self.clients.cinder().volumes.get(self.volume_id)
while vol.status == 'available' or vol.status == 'attaching': 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 yield
vol.get() vol.get()
if vol.status != 'in-use': if vol.status != 'in-use':
raise exception.Error(vol.status) raise exception.Error(vol.status)
logger.info('%s - complete' % str(self)) logger.info(_('%s - complete') % str(self))
class VolumeDetachTask(object): class VolumeDetachTask(object):
@ -236,7 +237,7 @@ class VolumeDetachTask(object):
try: try:
vol = self.clients.cinder().volumes.get(self.volume_id) vol = self.clients.cinder().volumes.get(self.volume_id)
except clients.cinderclient.exceptions.NotFound: except clients.cinderclient.exceptions.NotFound:
logger.warning('%s - volume not found' % str(self)) logger.warning(_('%s - volume not found') % str(self))
return return
server_api = self.clients.nova().volumes server_api = self.clients.nova().volumes
@ -252,7 +253,7 @@ class VolumeDetachTask(object):
try: try:
vol.get() vol.get()
while vol.status in ('in-use', 'detaching'): 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 yield
try: try:
@ -263,12 +264,13 @@ class VolumeDetachTask(object):
pass pass
vol.get() 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': if vol.status != 'available':
raise exception.Error(vol.status) raise exception.Error(vol.status)
except clients.cinderclient.exceptions.NotFound: 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): 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): if self._metadata_format_ok(new_metadata):
rsrc_metadata = self.metadata rsrc_metadata = self.metadata
if new_metadata['UniqueId'] in rsrc_metadata: if new_metadata['UniqueId'] in rsrc_metadata:
logger.warning("Overwriting Metadata item for UniqueId %s!" % logger.warning(_("Overwriting Metadata item for UniqueId %s!")
new_metadata['UniqueId']) % new_metadata['UniqueId'])
safe_metadata = {} safe_metadata = {}
for k in ('Data', 'Reason', 'Status'): for k in ('Data', 'Reason', 'Status'):
safe_metadata[k] = new_metadata[k] safe_metadata[k] = new_metadata[k]
@ -81,8 +81,8 @@ class WaitConditionHandle(signal_responder.SignalResponder):
rsrc_metadata.update({new_metadata['UniqueId']: safe_metadata}) rsrc_metadata.update({new_metadata['UniqueId']: safe_metadata})
self.metadata = rsrc_metadata self.metadata = rsrc_metadata
else: else:
logger.error("Metadata failed validation for %s" % self.name) logger.error(_("Metadata failed validation for %s") % self.name)
raise ValueError("Metadata format invalid") raise ValueError(_("Metadata format invalid"))
def get_status(self): def get_status(self):
''' '''
@ -120,7 +120,8 @@ class WaitConditionFailure(Exception):
class WaitConditionTimeout(Exception): class WaitConditionTimeout(Exception):
def __init__(self, wait_condition, handle): def __init__(self, wait_condition, handle):
reasons = handle.get_status_reason(STATUS_SUCCESS) 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: if reasons:
message += ' - %s' % reasons message += ' - %s' % reasons
@ -158,20 +159,20 @@ class WaitCondition(resource.Resource):
handle_url = self.properties['Handle'] handle_url = self.properties['Handle']
handle_id = identifier.ResourceIdentifier.from_arn_url(handle_url) handle_id = identifier.ResourceIdentifier.from_arn_url(handle_url)
if handle_id.tenant != self.stack.context.tenant_id: 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) handle_id.tenant)
if handle_id.stack_name != self.stack.name: 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) handle_id.stack_name)
if handle_id.stack_id != self.stack.id: 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) handle_id.stack_id)
if handle_id.resource_name not in self.stack: 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) handle_id.resource_name)
if not isinstance(self.stack[handle_id.resource_name], if not isinstance(self.stack[handle_id.resource_name],
WaitConditionHandle): WaitConditionHandle):
raise ValueError("WaitCondition invalid Handle %s" % raise ValueError(_("WaitCondition invalid Handle %s") %
handle_id.resource_name) handle_id.resource_name)
def _get_handle_resource_name(self): def _get_handle_resource_name(self):
@ -185,18 +186,20 @@ class WaitCondition(resource.Resource):
yield yield
except scheduler.Timeout: except scheduler.Timeout:
timeout = WaitConditionTimeout(self, handle) 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 raise timeout
handle_status = handle.get_status() handle_status = handle.get_status()
if any(s != STATUS_SUCCESS for s in handle_status): if any(s != STATUS_SUCCESS for s in handle_status):
failure = WaitConditionFailure(self, handle) 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 raise failure
if len(handle_status) >= self.count: if len(handle_status) >= self.count:
logger.info("%s Succeeded" % str(self)) logger.info(_("%s Succeeded") % str(self))
return return
def handle_create(self): def handle_create(self):

14
heat/engine/scheduler.py
View File

@ -105,7 +105,7 @@ class TaskRunner(object):
def _sleep(self, wait_time): def _sleep(self, wait_time):
"""Sleep for the specified number of seconds.""" """Sleep for the specified number of seconds."""
if ENABLE_SLEEP and wait_time is not None: 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) eventlet.sleep(wait_time)
def __call__(self, wait_time=1, timeout=None): def __call__(self, wait_time=1, timeout=None):
@ -128,7 +128,7 @@ class TaskRunner(object):
""" """
assert self._runner is None, "Task already started" 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: if timeout is not None:
self._timeout = Timeout(self, timeout) self._timeout = Timeout(self, timeout)
@ -140,7 +140,7 @@ class TaskRunner(object):
else: else:
self._runner = False self._runner = False
self._done = True self._done = True
logger.debug('%s done (not resumable)' % str(self)) logger.debug(_('%s done (not resumable)') % str(self))
def step(self): def step(self):
""" """
@ -151,7 +151,7 @@ class TaskRunner(object):
assert self._runner is not None, "Task not started" assert self._runner is not None, "Task not started"
if self._timeout is not None and self._timeout.expired(): 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: try:
self._runner.throw(self._timeout) self._runner.throw(self._timeout)
@ -161,13 +161,13 @@ class TaskRunner(object):
# Clean up in case task swallows exception without exiting # Clean up in case task swallows exception without exiting
self.cancel() self.cancel()
else: else:
logger.debug('%s running' % str(self)) logger.debug(_('%s running') % str(self))
try: try:
next(self._runner) next(self._runner)
except StopIteration: except StopIteration:
self._done = True self._done = True
logger.debug('%s complete' % str(self)) logger.debug(_('%s complete') % str(self))
return self._done return self._done
@ -184,7 +184,7 @@ class TaskRunner(object):
def cancel(self): def cancel(self):
"""Cancel the task if it is running.""" """Cancel the task if it is running."""
if self.started() and not self.done(): if self.started() and not self.done():
logger.debug('%s cancelled' % str(self)) logger.debug(_('%s cancelled') % str(self))
self._runner.close() self._runner.close()
self._done = True 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 files: Files referenced from the template
:param args: Request parameters/args passed from API :param args: Request parameters/args passed from API
""" """
logger.info('template is %s' % template) logger.info(_('template is %s') % template)
def _stack_create(stack): def _stack_create(stack):
# Create the stack, and create the periodic task if successful # 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 # Schedule a periodic watcher task for this stack
self._start_watch_task(stack.id, cnxt) self._start_watch_task(stack.id, cnxt)
else: 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): if db_api.stack_get_by_name(cnxt, stack_name):
raise exception.StackExists(stack_name=stack_name) raise exception.StackExists(stack_name=stack_name)
@ -301,7 +302,7 @@ class EngineService(service.Service):
arg4 -> Stack Input Params arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API 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 # Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity) db_stack = self._get_stack(cnxt, stack_identity)
@ -345,7 +346,7 @@ class EngineService(service.Service):
arg3 -> Template of stack you want to create. arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params arg4 -> Stack Input Params
""" """
logger.info('validate_template') logger.info(_('validate_template'))
if template is None: if template is None:
msg = _("No Template provided.") msg = _("No Template provided.")
return webob.exc.HTTPBadRequest(explanation=msg) return webob.exc.HTTPBadRequest(explanation=msg)
@ -425,7 +426,7 @@ class EngineService(service.Service):
""" """
st = self._get_stack(cnxt, stack_identity) 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) stack = parser.Stack.load(cnxt, stack=st)
@ -530,7 +531,7 @@ class EngineService(service.Service):
try: try:
akey_rsrc = self.find_physical_resource(cnxt, access_key) akey_rsrc = self.find_physical_resource(cnxt, access_key)
except exception.PhysicalResourceNotFound: except exception.PhysicalResourceNotFound:
logger.warning("access_key % not found!" % access_key) logger.warning(_("access_key % not found!") % access_key)
return False return False
akey_rsrc_id = identifier.ResourceIdentifier(**akey_rsrc) akey_rsrc_id = identifier.ResourceIdentifier(**akey_rsrc)
@ -540,9 +541,9 @@ class EngineService(service.Service):
ak_akey_rsrc = stack[akey_rsrc_id.resource_name] ak_akey_rsrc = stack[akey_rsrc_id.resource_name]
return ak_akey_rsrc.access_allowed(resource_name) return ak_akey_rsrc.access_allowed(resource_name)
else: else:
logger.warning("Cannot access resource from wrong stack!") logger.warning(_("Cannot access resource from wrong stack!"))
else: else:
logger.warning("Cannot access resource, invalid credentials!") logger.warning(_("Cannot access resource, invalid credentials!"))
return False return False
@ -553,7 +554,8 @@ class EngineService(service.Service):
if cfg.CONF.heat_stack_user_role in cnxt.roles: if cfg.CONF.heat_stack_user_role in cnxt.roles:
if not self._authorize_stack_user(cnxt, stack, resource_name): 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() raise exception.Forbidden()
if resource_name not in stack: if resource_name not in stack:
@ -632,7 +634,7 @@ class EngineService(service.Service):
Handle request to perform suspend action on a stack Handle request to perform suspend action on a stack
''' '''
def _stack_suspend(stack): def _stack_suspend(stack):
logger.debug("suspending stack %s" % stack.name) logger.debug(_("suspending stack %s") % stack.name)
stack.suspend() stack.suspend()
s = self._get_stack(cnxt, stack_identity) 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 Handle request to perform a resume action on a stack
''' '''
def _stack_resume(stack): def _stack_resume(stack):
logger.debug("resuming stack %s" % stack.name) logger.debug(_("resuming stack %s") % stack.name)
stack.resume() stack.resume()
s = self._get_stack(cnxt, stack_identity) s = self._get_stack(cnxt, stack_identity)
@ -700,11 +702,11 @@ class EngineService(service.Service):
# Retrieve the stored credentials & create context # Retrieve the stored credentials & create context
# Require tenant_safe=False to the stack_get to defeat tenant # Require tenant_safe=False to the stack_get to defeat tenant
# scoping otherwise we fail to retrieve the stack # 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() admin_context = context.get_admin_context()
stack = db_api.stack_get(admin_context, sid, tenant_safe=False) stack = db_api.stack_get(admin_context, sid, tenant_safe=False)
if not stack: if not stack:
logger.error("Unable to retrieve stack %s for periodic task" % logger.error(_("Unable to retrieve stack %s for periodic task") %
sid) sid)
return return
stack_context = self._load_user_creds(stack.user_creds_id) stack_context = self._load_user_creds(stack.user_creds_id)
@ -718,8 +720,8 @@ class EngineService(service.Service):
try: try:
wrs = db_api.watch_rule_get_all_by_stack(stack_context, sid) wrs = db_api.watch_rule_get_all_by_stack(stack_context, sid)
except Exception as ex: except Exception as ex:
logger.warn('periodic_task db error (%s) %s' % logger.warn(_('periodic_task db error (%(msg)s) %(ex)s') % {
('watch rule removed?', str(ex))) 'msg': 'watch rule removed?', 'ex': str(ex)})
return return
def run_alarm_action(actions, details): def run_alarm_action(actions, details):
@ -784,7 +786,7 @@ class EngineService(service.Service):
try: try:
wrn = [w.name for w in db_api.watch_rule_get_all(cnxt)] wrn = [w.name for w in db_api.watch_rule_get_all(cnxt)]
except Exception as ex: 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 return
wrs = [watchrule.WatchRule.load(cnxt, w) for w in wrn] 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 # namespace/metric, but we will want this at some point
# for now, the API can query all metric data and filter locally # for now, the API can query all metric data and filter locally
if metric_namespace is not None or metric_name is not None: 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 return
try: try:
wds = db_api.watch_data_get_all(cnxt) wds = db_api.watch_data_get_all(cnxt)
except Exception as ex: 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 return
result = [api.format_watch_data(w) for w in wds] 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.engine import resource
from heat.openstack.common import log from heat.openstack.common import log
from heat.openstack.common.gettextutils import _
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)
SIGNAL_TYPES = ( SIGNAL_TYPES = (
@ -49,7 +50,7 @@ class SignalResponder(resource.Resource):
self.physical_resource_name()) self.physical_resource_name())
kp = self.keystone().get_ec2_keypair(user_id) kp = self.keystone().get_ec2_keypair(user_id)
if not kp: 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) user_id)
else: else:
self.resource_id_set(user_id) 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.engine import template as tmpl
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -67,7 +68,7 @@ class StackResource(resource.Resource):
parent_resource=self) parent_resource=self)
if self._nested is None: 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 return self._nested
@ -170,7 +171,7 @@ class StackResource(resource.Resource):
nested_stack = self.nested() nested_stack = self.nested()
if nested_stack.state != (nested_stack.UPDATE, if nested_stack.state != (nested_stack.UPDATE,
nested_stack.COMPLETE): nested_stack.COMPLETE):
raise exception.Error("Nested stack update failed: %s" % raise exception.Error(_("Nested stack update failed: %s") %
nested_stack.status_reason) nested_stack.status_reason)
return True return True
@ -181,7 +182,7 @@ class StackResource(resource.Resource):
try: try:
stack = self.nested() stack = self.nested()
except exception.NotFound: except exception.NotFound:
logger.info("Stack not found to delete") logger.info(_("Stack not found to delete"))
else: else:
if stack is not None: if stack is not None:
delete_task = scheduler.TaskRunner(stack.delete) 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.engine import scheduler
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -77,7 +78,7 @@ class StackUpdate(object):
def _remove_backup_resource(self, prev_res): def _remove_backup_resource(self, prev_res):
if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE), if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE),
(prev_res.DELETE, 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() yield prev_res.destroy()
@staticmethod @staticmethod
@ -101,17 +102,18 @@ class StackUpdate(object):
# Swap in the backup resource if it is in a valid state, # Swap in the backup resource if it is in a valid state,
# instead of creating a new resource # instead of creating a new resource
if prev_res.status == prev_res.COMPLETE: 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], self._exchange_stacks(self.existing_stack[res_name],
prev_res) prev_res)
return return
logger.debug("Deleting backup Resource %s" % res_name) logger.debug(_("Deleting backup Resource %s") % res_name)
yield prev_res.destroy() yield prev_res.destroy()
# Back up existing resource # Back up existing resource
if res_name in self.existing_stack: 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] existing_res = self.existing_stack[res_name]
self.previous_stack[res_name] = existing_res self.previous_stack[res_name] = existing_res
existing_res.state_set(existing_res.UPDATE, existing_res.COMPLETE) existing_res.state_set(existing_res.UPDATE, existing_res.COMPLETE)
@ -131,8 +133,10 @@ class StackUpdate(object):
except resource.UpdateReplace: except resource.UpdateReplace:
pass pass
else: else:
logger.info("Resource %s for stack %s updated" % logger.info(_("Resource %(res_name)s for stack %(stack_name)s"
(res_name, self.existing_stack.name)) " updated") % {
'res_name': res_name,
'stack_name': self.existing_stack.name})
return return
yield self._create_resource(new_res) yield self._create_resource(new_res)

38
heat/engine/watchrule.py
View File

@ -17,6 +17,7 @@
import datetime import datetime
from heat.common import exception from heat.common import exception
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
from heat.openstack.common import timeutils from heat.openstack.common import timeutils
from heat.engine import timestamp from heat.engine import timestamp
from heat.db import api as db_api from heat.db import api as db_api
@ -75,8 +76,9 @@ class WatchRule(object):
try: try:
watch = db_api.watch_rule_get_by_name(context, watch_name) watch = db_api.watch_rule_get_by_name(context, watch_name)
except Exception as ex: except Exception as ex:
logger.warn('WatchRule.load (%s) db error %s' % logger.warn(_('WatchRule.load (%(watch_name)s) db error '
(watch_name, str(ex))) '%(ex)s') % {
'watch_name': watch_name, 'ex': str(ex)})
if watch is None: if watch is None:
raise exception.WatchRuleNotFound(watch_name=watch_name) raise exception.WatchRuleNotFound(watch_name=watch_name)
else: else:
@ -209,7 +211,7 @@ class WatchRule(object):
data = 0 data = 0
for d in self.watch_data: for d in self.watch_data:
if d.created_at < self.now - self.timeperiod: if d.created_at < self.now - self.timeperiod:
logger.debug('ignoring %s' % str(d.data)) logger.debug(_('ignoring %s') % str(d.data))
continue continue
data = data + float(d.data[self.rule['MetricName']]['Value']) data = data + float(d.data[self.rule['MetricName']]['Value'])
@ -250,7 +252,7 @@ class WatchRule(object):
self.stack_id, self.name, new_state) self.stack_id, self.name, new_state)
actions = [] actions = []
if self.ACTION_MAP[new_state] not in self.rule: 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) new_state)
else: else:
s = db_api.stack_get(self.context, self.stack_id) 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]]: for refid in self.rule[self.ACTION_MAP[new_state]]:
actions.append(stack.resource_by_refid(refid).signal) actions.append(stack.resource_by_refid(refid).signal)
else: else:
logger.warning("Could not process watch state %s for stack" % logger.warning(_("Could not process watch state %s for stack")
new_state) % new_state)
return actions return actions
def _to_ceilometer(self, data): def _to_ceilometer(self, data):
@ -281,7 +283,8 @@ class WatchRule(object):
dims = dims[0] dims = dims[0]
sample['resource_metadata'] = dims sample['resource_metadata'] = dims
sample['resource_id'] = dims.get('InstanceId') 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) clients.ceilometer().samples.create(**sample)
def create_watch_data(self, data): def create_watch_data(self, data):
@ -293,7 +296,7 @@ class WatchRule(object):
return return
if self.state == self.SUSPENDED: 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) % self.name)
return [] return []
@ -303,8 +306,9 @@ class WatchRule(object):
# options, e.g --haproxy try to push multiple metrics when we # options, e.g --haproxy try to push multiple metrics when we
# actually only care about one (the one we're alarming on) # actually only care about one (the one we're alarming on)
# so just ignore any data which doesn't contain MetricName # so just ignore any data which doesn't contain MetricName
logger.debug('Ignoring metric data (only accept %s) : %s' % logger.debug(_('Ignoring metric data (only accept %(metric)s) '
(self.rule['MetricName'], data)) ': %(data)s') % {
'metric': self.rule['MetricName'], 'data': data})
return return
watch_data = { watch_data = {
@ -312,7 +316,8 @@ class WatchRule(object):
'watch_rule_id': self.id 'watch_rule_id': self.id
} }
wd = db_api.watch_data_create(None, watch_data) 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): def state_set(self, state):
''' '''
@ -337,11 +342,14 @@ class WatchRule(object):
if state != self.state: if state != self.state:
actions = self.rule_actions(state) actions = self.rule_actions(state)
if actions: if actions:
logger.debug("Overriding state %s for watch %s with %s" % logger.debug(_("Overriding state %(self_state)s for watch "
(self.state, self.name, state)) "%(name)s with %(state)s") % {
'self_state': self.state, 'name': self.name,
'state': state})
else: else:
logger.warning("Unable to override state %s for watch %s" % logger.warning(_("Unable to override state %(state)s for "
(self.state, self.name)) "watch %(name)s") % {
'state': self.state, 'name': self.name})
return actions 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.engine import signal_responder
from heat.openstack.common import log as logging from heat.openstack.common import log as logging
from heat.openstack.common.gettextutils import _
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -29,22 +30,27 @@ class GenericResource(resource.Resource):
'Foo': 'Another generic attribute'} 'Foo': 'Another generic attribute'}
def handle_create(self): 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): 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): 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): def _resolve_attribute(self, name):
return self.name return self.name
def handle_suspend(self): 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): 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): class ResourceWithProps(GenericResource):
@ -61,8 +67,8 @@ class SignalResource(signal_responder.SignalResponder):
attributes_schema = {'AlarmUrl': 'Get a signed webhook'} attributes_schema = {'AlarmUrl': 'Get a signed webhook'}
def handle_signal(self, details=None): def handle_signal(self, details=None):
logger.warning('Signaled resource (Type "%s") %s' % (self.type(), logger.warning(_('Signaled resource (Type "%(type)s") %(details)s')
details)) % {'type': self.type(), 'details': details})
def _resolve_attribute(self, name): def _resolve_attribute(self, name):
if name == 'AlarmUrl' and self.resource_id is not None: if name == 'AlarmUrl' and self.resource_id is not None: