← Back to branch summary

~ubuntu-branches/ubuntu/trusty/heat/trusty-security

« back to all changes in this revision

Viewing changes to heat/db/sqlalchemy/models.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Yolanda Robla, Chuck Short
  • Date: 2013-07-22 16:22:29 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130722162229-zzvfu40id94ii0hc
Tags: 2013.2~b2-0ubuntu1
[ Yolanda Robla ]
* debian/tests: added autopkg tests

[ Chuck Short ]
* New upstream release
* debian/control:
  - Add python-pbr to build-depends.
  - Add python-d2to to build-depends.
  - Dropped python-argparse.
  - Add python-six to build-depends.
  - Dropped python-sendfile.
  - Dropped python-nose.
  - Added testrepository.
  - Added python-testtools.
* debian/rules: Run testrepository instead of nosetets.
* debian/patches/removes-lxml-version-limitation-from-pip-requires.patch: Dropped
  no longer needed.
* debian/patches/fix-package-version-detection-when-building-doc.patch: Dropped
  no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/db/sqlalchemy/models.py
15
15
SQLAlchemy models for heat data.
16
16
"""
17
17
 
18
 
from sqlalchemy import *
 
18
import sqlalchemy
 
19
 
19
20
from sqlalchemy.orm import relationship, backref, object_mapper
20
21
from sqlalchemy.exc import IntegrityError
21
22
from sqlalchemy.ext.declarative import declarative_base
22
 
from sqlalchemy import types as types
23
 
from json import dumps, loads
 
23
from sqlalchemy import types
 
24
from json import dumps
 
25
from json import loads
 
26
from heat.openstack.common import exception
24
27
from heat.openstack.common import uuidutils
25
28
from heat.openstack.common import timeutils
26
29
from heat.db.sqlalchemy.session import get_session
43
46
    """Base class for Heat Models."""
44
47
    __table_args__ = {'mysql_engine': 'InnoDB'}
45
48
    __table_initialized__ = False
46
 
    created_at = Column(DateTime, default=timeutils.utcnow)
47
 
    updated_at = Column(DateTime, onupdate=timeutils.utcnow)
 
49
    created_at = sqlalchemy.Column(sqlalchemy.DateTime,
 
50
                                   default=timeutils.utcnow)
 
51
    updated_at = sqlalchemy.Column(sqlalchemy.DateTime,
 
52
                                   onupdate=timeutils.utcnow)
48
53
 
49
54
    def save(self, session=None):
50
55
        """Save this object."""
55
60
        session.add(self)
56
61
        try:
57
62
            session.flush()
58
 
        except IntegrityError, e:
 
63
        except IntegrityError as e:
59
64
            if str(e).endswith('is not unique'):
60
65
                raise exception.Duplicate(str(e))
61
66
            else:
106
111
        return n, getattr(self, n)
107
112
 
108
113
    def update(self, values):
109
 
        """Make the model object behave like a dict"""
 
114
        """Make the model object behave like a dict."""
110
115
        for k, v in values.iteritems():
111
116
            setattr(self, k, v)
112
117
 
123
128
    def iteritems(self):
124
129
        """Make the model object behave like a dict.
125
130
 
126
 
        Includes attributes from joins."""
 
131
        Includes attributes from joins.
 
132
        """
127
133
        local = dict(self)
128
134
        joined = dict([(k, v) for k, v in self.__dict__.iteritems()
129
135
                      if not k[0] == '_'])
135
141
    """Represents an unparsed template which should be in JSON format."""
136
142
 
137
143
    __tablename__ = 'raw_template'
138
 
    id = Column(Integer, primary_key=True)
139
 
    template = Column(Json)
 
144
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
 
145
    template = sqlalchemy.Column(Json)
140
146
 
141
147
 
142
148
class Stack(BASE, HeatBase):
144
150
 
145
151
    __tablename__ = 'stack'
146
152
 
147
 
    id = Column(String, primary_key=True, default=uuidutils.generate_uuid)
148
 
    name = Column(String)
149
 
    raw_template_id = Column(
150
 
        Integer,
151
 
        ForeignKey('raw_template.id'),
 
153
    id = sqlalchemy.Column(sqlalchemy.String, primary_key=True,
 
154
                           default=uuidutils.generate_uuid)
 
155
    name = sqlalchemy.Column(sqlalchemy.String)
 
156
    raw_template_id = sqlalchemy.Column(
 
157
        sqlalchemy.Integer,
 
158
        sqlalchemy.ForeignKey('raw_template.id'),
152
159
        nullable=False)
153
160
    raw_template = relationship(RawTemplate, backref=backref('stack'))
154
 
    username = Column(String)
155
 
    tenant = Column(String)
156
 
    status = Column('status', String)
157
 
    status_reason = Column('status_reason', String)
158
 
    parameters = Column('parameters', Json)
159
 
    user_creds_id = Column(
160
 
        Integer,
161
 
        ForeignKey('user_creds.id'),
 
161
    username = sqlalchemy.Column(sqlalchemy.String)
 
162
    tenant = sqlalchemy.Column(sqlalchemy.String)
 
163
    action = sqlalchemy.Column('action', sqlalchemy.String)
 
164
    status = sqlalchemy.Column('status', sqlalchemy.String)
 
165
    status_reason = sqlalchemy.Column('status_reason', sqlalchemy.String)
 
166
    parameters = sqlalchemy.Column('parameters', Json)
 
167
    user_creds_id = sqlalchemy.Column(
 
168
        sqlalchemy.Integer,
 
169
        sqlalchemy.ForeignKey('user_creds.id'),
162
170
        nullable=False)
163
 
    owner_id = Column(String, nullable=True)
164
 
    timeout = Column(Integer)
165
 
    disable_rollback = Column(Boolean)
 
171
    owner_id = sqlalchemy.Column(sqlalchemy.String, nullable=True)
 
172
    timeout = sqlalchemy.Column(sqlalchemy.Integer)
 
173
    disable_rollback = sqlalchemy.Column(sqlalchemy.Boolean)
166
174
 
167
175
 
168
176
class UserCreds(BASE, HeatBase):
173
181
 
174
182
    __tablename__ = 'user_creds'
175
183
 
176
 
    id = Column(Integer, primary_key=True)
177
 
    username = Column(String)
178
 
    password = Column(String)
179
 
    service_user = Column(String)
180
 
    service_password = Column(String)
181
 
    tenant = Column(String)
182
 
    auth_url = Column(String)
183
 
    aws_auth_url = Column(String)
184
 
    tenant_id = Column(String)
185
 
    aws_creds = Column(String)
 
184
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
 
185
    username = sqlalchemy.Column(sqlalchemy.String)
 
186
    password = sqlalchemy.Column(sqlalchemy.String)
 
187
    service_user = sqlalchemy.Column(sqlalchemy.String)
 
188
    service_password = sqlalchemy.Column(sqlalchemy.String)
 
189
    tenant = sqlalchemy.Column(sqlalchemy.String)
 
190
    auth_url = sqlalchemy.Column(sqlalchemy.String)
 
191
    aws_auth_url = sqlalchemy.Column(sqlalchemy.String)
 
192
    tenant_id = sqlalchemy.Column(sqlalchemy.String)
 
193
    aws_creds = sqlalchemy.Column(sqlalchemy.String)
186
194
    stack = relationship(Stack, backref=backref('user_creds'))
187
195
 
188
196
 
191
199
 
192
200
    __tablename__ = 'event'
193
201
 
194
 
    id = Column(Integer, primary_key=True)
195
 
    stack_id = Column(String, ForeignKey('stack.id'), nullable=False)
 
202
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
 
203
    stack_id = sqlalchemy.Column(sqlalchemy.String,
 
204
                                 sqlalchemy.ForeignKey('stack.id'),
 
205
                                 nullable=False)
196
206
    stack = relationship(Stack, backref=backref('events'))
197
207
 
198
 
    name = Column(String)
199
 
    logical_resource_id = Column(String)
200
 
    physical_resource_id = Column(String)
201
 
    resource_status_reason = Column(String)
202
 
    resource_type = Column(String)
203
 
    resource_properties = Column(PickleType)
 
208
    resource_action = sqlalchemy.Column(sqlalchemy.String)
 
209
    resource_status = sqlalchemy.Column(sqlalchemy.String)
 
210
    logical_resource_id = sqlalchemy.Column(sqlalchemy.String)
 
211
    physical_resource_id = sqlalchemy.Column(sqlalchemy.String)
 
212
    resource_status_reason = sqlalchemy.Column(sqlalchemy.String)
 
213
    resource_type = sqlalchemy.Column(sqlalchemy.String)
 
214
    resource_properties = sqlalchemy.Column(sqlalchemy.PickleType)
 
215
 
 
216
 
 
217
class ResourceData(BASE, HeatBase):
 
218
    """Key/value store of arbitrary, resource-specific data."""
 
219
 
 
220
    __tablename__ = 'resource_data'
 
221
 
 
222
    id = sqlalchemy.Column('id',
 
223
                           sqlalchemy.Integer,
 
224
                           primary_key=True,
 
225
                           nullable=False)
 
226
    key = sqlalchemy.Column('key', sqlalchemy.String)
 
227
    value = sqlalchemy.Column('value', sqlalchemy.String)
 
228
    redact = sqlalchemy.Column('redact', sqlalchemy.Boolean)
 
229
    resource_id = sqlalchemy.Column('resource_id',
 
230
                                    sqlalchemy.String,
 
231
                                    sqlalchemy.ForeignKey('resource.id'),
 
232
                                    nullable=False)
204
233
 
205
234
 
206
235
class Resource(BASE, HeatBase):
208
237
 
209
238
    __tablename__ = 'resource'
210
239
 
211
 
    id = Column(Integer, primary_key=True)
212
 
    state = Column('state', String)
213
 
    name = Column('name', String, nullable=False)
214
 
    nova_instance = Column('nova_instance', String)
215
 
    state_description = Column('state_description', String)
 
240
    id = sqlalchemy.Column(sqlalchemy.String,
 
241
                           primary_key=True,
 
242
                           default=uuidutils.generate_uuid)
 
243
    action = sqlalchemy.Column('action', sqlalchemy.String)
 
244
    status = sqlalchemy.Column('status', sqlalchemy.String)
 
245
    name = sqlalchemy.Column('name', sqlalchemy.String, nullable=False)
 
246
    nova_instance = sqlalchemy.Column('nova_instance', sqlalchemy.String)
 
247
    status_reason = sqlalchemy.Column('status_reason', sqlalchemy.String)
216
248
    # odd name as "metadata" is reserved
217
 
    rsrc_metadata = Column('rsrc_metadata', Json)
 
249
    rsrc_metadata = sqlalchemy.Column('rsrc_metadata', Json)
218
250
 
219
 
    stack_id = Column(String, ForeignKey('stack.id'), nullable=False)
 
251
    stack_id = sqlalchemy.Column(sqlalchemy.String,
 
252
                                 sqlalchemy.ForeignKey('stack.id'),
 
253
                                 nullable=False)
220
254
    stack = relationship(Stack, backref=backref('resources'))
 
255
    data = relationship(ResourceData,
 
256
                        cascade="all,delete",
 
257
                        backref=backref('resource', lazy='joined'))
221
258
 
222
259
 
223
260
class WatchRule(BASE, HeatBase):
225
262
 
226
263
    __tablename__ = 'watch_rule'
227
264
 
228
 
    id = Column(Integer, primary_key=True)
229
 
    name = Column('name', String, nullable=False)
230
 
    rule = Column('rule', Json)
231
 
    state = Column('state', String)
232
 
    last_evaluated = Column(DateTime, default=timeutils.utcnow)
 
265
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
 
266
    name = sqlalchemy.Column('name', sqlalchemy.String, nullable=False)
 
267
    rule = sqlalchemy.Column('rule', Json)
 
268
    state = sqlalchemy.Column('state', sqlalchemy.String)
 
269
    last_evaluated = sqlalchemy.Column(sqlalchemy.DateTime,
 
270
                                       default=timeutils.utcnow)
233
271
 
234
 
    stack_id = Column(String, ForeignKey('stack.id'), nullable=False)
 
272
    stack_id = sqlalchemy.Column(sqlalchemy.String,
 
273
                                 sqlalchemy.ForeignKey('stack.id'),
 
274
                                 nullable=False)
235
275
    stack = relationship(Stack, backref=backref('watch_rule'))
236
276
 
237
277
 
240
280
 
241
281
    __tablename__ = 'watch_data'
242
282
 
243
 
    id = Column(Integer, primary_key=True)
244
 
    data = Column('data', Json)
 
283
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
 
284
    data = sqlalchemy.Column('data', Json)
245
285
 
246
 
    watch_rule_id = Column(
247
 
        Integer,
248
 
        ForeignKey('watch_rule.id'),
 
286
    watch_rule_id = sqlalchemy.Column(
 
287
        sqlalchemy.Integer,
 
288
        sqlalchemy.ForeignKey('watch_rule.id'),
249
289
        nullable=False)
250
290
    watch_rule = relationship(WatchRule, backref=backref('watch_data'))