return IMPL.raw_template_create(context, values)
-def parsed_template_get(context, template_id):
- return IMPL.parsed_template_get(context, template_id)
-
-
-def parsed_template_get_all(context):
- return IMPL.parsed_template_get_all(context)
-
-
-def parsed_template_create(context, values):
- return IMPL.parsed_template_create(context, values)
-
-
def resource_get(context, resource_id):
return IMPL.resource_get(context, resource_id)
return raw_template_ref
-def parsed_template_get(context, template_id):
- result = model_query(context, models.ParsedTemplate).\
- filter_by(id=template_id).first()
- return result
-
-
-def parsed_template_get_all(context):
- results = model_query(context, models.ParsedTemplate).all()
-
- if not results:
- raise NotFound('no parsed templates were found')
-
- return results
-
-
-def parsed_template_create(context, values):
- parsed_template_ref = models.ParsedTemplate()
- parsed_template_ref.update(values)
- parsed_template_ref.save()
- return parsed_template_ref
-
-
def resource_get(context, resource_id):
result = model_query(context, models.Resource).\
filter_by(id=resource_id).first()
for e in s.events:
session.delete(e)
- rpt = {}
- rrt = {}
for r in s.resources:
- rpt[r.parsed_template.id] = r.parsed_template
- rrt[r.parsed_template.raw_template.id] = \
- r.parsed_template.raw_template
session.delete(r)
- for pt in rpt.values():
- session.delete(pt)
-
- for rt in rrt.values():
- session.delete(rt)
+ rt = s.raw_template
session.delete(s)
+ session.delete(rt)
+
session.flush()
--- /dev/null
+from sqlalchemy import *
+from migrate import *
+
+
+def upgrade(migrate_engine):
+ meta = MetaData(bind=migrate_engine)
+
+ def fk_name(table, ref_column):
+ for fk in table.foreign_keys:
+ if fk.column == ref_column:
+ return fk.name
+
+ resource = Table('resource', meta, autoload=True)
+ parsed_template = Table('parsed_template', meta, autoload=True)
+
+ res_kc = ForeignKeyConstraint([resource.c.parsed_template_id],
+ [parsed_template.c.id],
+ name=fk_name(resource,
+ parsed_template.c.id))
+ try:
+ res_kc.drop()
+ except NotSupportedError:
+ # SQLite (used in unit tests) cannot drop a Foreign Key constraint
+ pass
+
+ resource.c.parsed_template_id.drop()
+
+ parsed_template.drop()
+
+
+def downgrade(migrate_engine):
+ meta = MetaData(bind=migrate_engine)
+
+ raw_template = Table('raw_template', meta, autoload=True)
+
+ parsed_template = Table(
+ 'parsed_template', meta,
+ Column('id', Integer, primary_key=True),
+ Column('created_at', DateTime(timezone=False)),
+ Column('updated_at', DateTime(timezone=False)),
+ Column('raw_template_id', Integer, ForeignKey("raw_template.id"),
+ nullable=False),
+ Column('template', Text())
+ )
+ parsed_template.create()
+
+ resource = Table('resource', meta, autoload=True)
+ Column('parsed_template_id', Integer, ForeignKey('parsed_template.id'),
+ nullable=True).create(resource)
__tablename__ = 'raw_template'
id = Column(Integer, primary_key=True)
template = Column(Json)
- parsed_template = relationship("ParsedTemplate",
- uselist=False, backref="raw_template")
-
-
-class ParsedTemplate(BASE, HeatBase):
- """Represents a parsed template."""
-
- __tablename__ = 'parsed_template'
- id = Column(Integer, primary_key=True)
- template = Column(Json)
- raw_template_id = Column(Integer, ForeignKey('raw_template.id'),
- nullable=False)
class Stack(BASE, HeatBase):
state_description = Column('state_description', String)
# odd name as "metadata" is reserved
rsrc_metadata = Column('rsrc_metadata', Json)
- parsed_template_id = Column(Integer, ForeignKey('parsed_template.id'),
- nullable=True)
- parsed_template = relationship(ParsedTemplate,
- backref=backref('resources'))
stack_id = Column(Integer, ForeignKey('stack.id'),
nullable=False)
return res
for s in stacks:
ps = parser.Stack(context, s.name,
- s.raw_template.parsed_template.template,
- s.id, _extract_user_params(params))
+ s.raw_template.template,
+ s.id, s.parameters)
mem = {}
mem['StackId'] = "/".join([s.name, str(s.id)])
mem['StackName'] = s.name
s = db_api.stack_get_by_name(context, stack)
if s:
ps = parser.Stack(context, s.name,
- s.raw_template.parsed_template.template,
- s.id, _extract_user_params(params))
+ s.raw_template.template,
+ s.id, s.parameters)
mem = {}
mem['StackId'] = "/".join([s.name, str(s.id)])
mem['StackName'] = s.name
new_s = db_api.stack_create(context, s)
stack.id = new_s.id
- pt = {}
- pt['template'] = stack.t
- pt['raw_template_id'] = new_rt.id
- new_pt = db_api.parsed_template_create(None, pt)
-
- stack.parsed_template_id = new_pt.id
-
greenpool.spawn_n(stack.create, **_extract_args(params))
return {'StackId': "/".join([new_s.name, str(new_s.id)])}
self.res = {}
self.doc = None
self.name = stack_name
- self.parsed_template_id = 0
self.metadata_server = metadata_server
# Default Parameters
response['ValidateTemplateResult']['Parameters'].append(res)
return response
- def parsed_template_get(self):
- stack = None
- if self.parsed_template_id == 0:
- if self.id == 0:
- stack = db_api.stack_get(self.context, self.id)
- else:
- stack = db_api.stack_get_by_name(self.context, self.name)
-
- if stack is None:
- return None
-
- self.parsed_template_id = stack.raw_template.parsed_template.id
- return db_api.parsed_template_get(self.context,
- self.parsed_template_id)
-
- def update_parsed_template(self):
- '''
- Update the parsed template after each resource has been
- created, so commands like describe will work.
- '''
- pt = self.parsed_template_get()
- if pt:
- template = self.t.copy()
- template['Resources'] = dict((k, r.parsed_template())
- for (k, r) in self.resources.items())
- pt.update_and_save({'template': template})
- else:
- logger.warn('Cant find parsed template to update %d' %
- self.parsed_template_id)
-
def state_set(self, new_status, reason='change in resource state'):
if self.id != 0:
stack = db_api.stack_get(self.context, self.id)
reason = 'Resource %s failed with: %s' % (str(res),
result)
- try:
- self.update_parsed_template()
- except Exception as ex:
- logger.exception('update_parsed_template')
-
else:
res.state_set(res.CREATE_FAILED,
'Stack creation aborted')
stop resource_name and all that depend on it
start resource_name and all that depend on it
'''
-
- if self.parsed_template_id == 0:
- stack = db_api.stack_get(self.context, self.id)
- if stack:
- self.parsed_template_id = stack.raw_template.parsed_template.id
-
deps = self.dependencies[self[resource_name]]
failed = False
except Exception as ex:
logger.exception('create')
failed = True
-
- try:
- self.update_parsed_template()
- except Exception as ex:
- logger.exception('update_parsed_template')
else:
res.state_set(res.CREATE_FAILED)
# TODO(asalkeld) if any of this fails we Should
try:
rs = {'state': self.state,
'stack_id': self.stack.id,
- 'parsed_template_id': self.stack.parsed_template_id,
'nova_instance': self.instance_id,
'name': self.name,
'rsrc_metadata': metadata,
raise exception.NotFound('Nested stack not found in DB')
n = parser.Stack(self.stack.context, st.name,
- st.raw_template.parsed_template.template,
+ st.raw_template.template,
self.instance_id, self._params())
self._nested = n
new_s = db_api.stack_create(None, s)
self._nested.id = new_s.id
- pt = {'template': self._nested.t, 'raw_template_id': new_rt.id}
- new_pt = db_api.parsed_template_create(None, pt)
-
- self._nested.parsed_template_id = new_pt.id
-
self._nested.create()
self.instance_id_set(self._nested.id)
s['username'] = ct['username']
new_s = db_api.stack_create(None, s)
stack.id = new_s.id
- pt = {}
- pt['template'] = stack.t
- pt['raw_template_id'] = new_rt.id
- new_pt = db_api.parsed_template_create(None, pt)
stack.create()
self.assertNotEqual(stack.resources['WebServer'], None)
self.assertTrue(stack.resources['WebServer'].instance_id > 0)
s['username'] = ct['username']
new_s = db_api.stack_create(None, s)
stack.id = new_s.id
- pt = {}
- pt['template'] = stack.t
- pt['raw_template_id'] = new_rt.id
- new_pt = db_api.parsed_template_create(None, pt)
stack.create()
self.assertNotEqual(stack.resources['WebServer'], None)
s['username'] = ct['username']
new_s = db_api.stack_create(ctx, s)
stack.id = new_s.id
- pt = {}
- pt['template'] = stack.t
- pt['raw_template_id'] = new_rt.id
- new_pt = db_api.parsed_template_create(ctx, pt)
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
stack.create()
s['username'] = ct['username']
new_s = db_api.stack_create(None, s)
stack.id = new_s.id
- pt = {}
- pt['template'] = stack.t
- pt['raw_template_id'] = new_rt.id
- new_pt = db_api.parsed_template_create(None, pt)
- stack.parsed_template_id = new_pt.id
return stack
def test_post_success_to_handle(self):
Code Review / openstack-build / heat-build.git / commitdiff