from heat.engine import auth
-def model_query(context, *args, **kwargs):
- """
- :param session: if present, the session to use
- """
- session = kwargs.get('session') or get_session()
-
+def model_query(context, *args):
+ session = _session(context)
query = session.query(*args)
return query
+def _session(context):
+ return (context and context.session) or get_session()
+
+
def raw_template_get(context, template_id):
result = model_query(context, models.RawTemplate).get(template_id)
def raw_template_create(context, values):
raw_template_ref = models.RawTemplate()
raw_template_ref.update(values)
- raw_template_ref.save()
+ raw_template_ref.save(_session(context))
return raw_template_ref
def resource_create(context, values):
resource_ref = models.Resource()
resource_ref.update(values)
- resource_ref.save()
+ resource_ref.save(_session(context))
return resource_ref
def stack_create(context, values):
stack_ref = models.Stack()
stack_ref.update(values)
- stack_ref.save()
+ stack_ref.save(_session(context))
return stack_ref
old_template_id = stack.raw_template_id
stack.update(values)
- stack.save()
+ stack.save(_session(context))
# When the raw_template ID changes, we delete the old template
# after storing the new template ID
session.flush()
-def user_creds_create(values):
+def user_creds_create(context):
+ values = context.to_dict()
user_creds_ref = models.UserCreds()
user_creds_ref.update(values)
user_creds_ref.password = auth.encrypt(values['password'])
user_creds_ref.service_password = auth.encrypt(values['service_password'])
user_creds_ref.aws_creds = auth.encrypt(values['aws_creds'])
- user_creds_ref.save()
+ user_creds_ref.save(_session(context))
return user_creds_ref
def event_create(context, values):
event_ref = models.Event()
event_ref.update(values)
- event_ref.save()
+ event_ref.save(_session(context))
return event_ref
def watch_rule_create(context, values):
obj_ref = models.WatchRule()
obj_ref.update(values)
- obj_ref.save()
+ obj_ref.save(_session(context))
return obj_ref
(watch_id, 'that does not exist'))
wr.update(values)
- wr.save()
+ wr.save(_session(context))
def watch_rule_delete(context, watch_name):
def watch_data_create(context, values):
obj_ref = models.WatchData()
obj_ref.update(values)
- obj_ref.save()
+ obj_ref.save(_session(context))
return obj_ref
# License for the specific language governing permissions and limitations
# under the License.
+import functools
import webob
from heat.common import context
logger = logging.getLogger(__name__)
+def request_context(func):
+ @functools.wraps(func)
+ def wrapped(self, ctx, *args, **kwargs):
+ if ctx is not None and not isinstance(ctx, context.RequestContext):
+ ctx = context.RequestContext.from_dict(ctx.to_dict())
+ return func(self, ctx, *args, **kwargs)
+ return wrapped
+
+
class EngineService(service.Service):
"""
Manages the running instances from creation to destruction.
context=stack_context,
sid=s.id)
+ @request_context
def identify_stack(self, context, stack_name):
"""
The identify_stack method returns the full stack identifier for a
return s
+ @request_context
def show_stack(self, context, stack_identity):
"""
The show_stack method returns the attributes of one stack.
return {'stacks': [format_stack_detail(s) for s in stacks]}
+ @request_context
def list_stacks(self, context):
"""
The list_stacks method returns attributes of all stacks.
return {'stacks': [format_stack_detail(s) for s in stacks]}
+ @request_context
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
return dict(stack.identifier())
+ @request_context
def update_stack(self, context, stack_identity, template, params, args):
"""
The update_stack method updates an existing stack based on the
return dict(current_stack.identifier())
+ @request_context
def validate_template(self, context, template):
"""
The validate_template method uses the stack parser to check
}
return result
+ @request_context
def get_template(self, context, stack_identity):
"""
Get the template.
return s.raw_template.template
return None
+ @request_context
def delete_stack(self, context, stack_identity):
"""
The delete_stack method deletes a given stack.
self.tg.add_thread(stack.delete)
return None
+ @request_context
def list_events(self, context, stack_identity):
"""
The list_events method lists all events associated with a given stack.
return {'events': [api.format_event(context, e) for e in events]}
+ @request_context
def describe_stack_resource(self, context, stack_identity, resource_name):
s = self._get_stack(context, stack_identity)
return api.format_stack_resource(stack[resource_name])
+ @request_context
def describe_stack_resources(self, context, stack_identity,
physical_resource_id, logical_resource_id):
if stack_identity is not None:
for resource in stack if resource.id is not None and
name_match(resource)]
+ @request_context
def list_stack_resources(self, context, stack_identity):
s = self._get_stack(context, stack_identity)
return [api.format_stack_resource(resource, detail=False)
for resource in stack if resource.id is not None]
+ @request_context
def metadata_update(self, context, stack_id, resource_name, metadata):
"""
Update the metadata for the given resource.
rule = watchrule.WatchRule.load(context, watch=wr)
rule.evaluate()
+ @request_context
def create_watch_data(self, context, watch_name, stats_data):
'''
This could be used by CloudWatch and WaitConditions
logger.debug('new watch:%s data:%s' % (watch_name, str(stats_data)))
return stats_data
+ @request_context
def show_watch(self, context, watch_name):
'''
The show_watch method returns the attributes of one watch/alarm
result = [api.format_watch(w) for w in wrs]
return result
+ @request_context
def show_watch_metric(self, context, namespace=None, metric_name=None):
'''
The show_watch method returns the datapoints for a metric
result = [api.format_watch_data(w) for w in wds]
return result
+ @request_context
def set_watch_state(self, context, watch_name, state):
'''
Temporarily set the state of a given watch
Code Review / openstack-build / heat-build.git / commitdiff