← Back to branch summary

~ubuntu-branches/ubuntu/quantal/quantum/quantal-updates

« back to all changes in this revision

Viewing changes to quantum/db/api.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Adam Gandelman
  • Date: 2012-06-22 12:49:23 UTC
  • mfrom: (2.1.8)
  • Revision ID: package-import@ubuntu.com-20120622124923-5q185p2z7nooaxs0
Tags: 2012.2~f2~20120621.868-0ubuntu1
https://launchpad.net/bugs/999142
[ Chuck Short ]
* New upstream release.
* Add missing upsart jobs for agents. 
* Add sudo wrapper for quantum-rootwrap. (LP: #999142)

[ Adam Gandelman ]
* debian/control: Fix spacing issues that cause mk-build-deps to fail.
* debian/quantum-server.install: Install new plugins config directory
  instead of old .ini.

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantum/db/api.py
18
18
# @author: Dan Wendlandt, Nicira Networks, Inc.
19
19
 
20
20
import logging
 
21
import time
 
22
 
21
23
import sqlalchemy as sql
22
24
from sqlalchemy import create_engine
23
25
from sqlalchemy.exc import DisconnectionError
25
27
 
26
28
from quantum.api.api_common import OperationalStatus
27
29
from quantum.common import exceptions as q_exc
28
 
from quantum.db import models
 
30
from quantum.db import model_base, models
 
31
 
 
32
 
 
33
LOG = logging.getLogger(__name__)
29
34
 
30
35
 
31
36
_ENGINE = None
32
37
_MAKER = None
33
 
BASE = models.BASE
34
 
LOG = logging.getLogger('quantum.db.api')
 
38
BASE = model_base.BASE
35
39
 
36
40
 
37
41
class MySQLPingListener(object):
75
79
            engine_args['listeners'] = [MySQLPingListener()]
76
80
 
77
81
        _ENGINE = create_engine(options['sql_connection'], **engine_args)
78
 
        register_models()
79
 
 
80
 
 
81
 
def clear_db():
 
82
        base = options.get('base', BASE)
 
83
        if not register_models(base):
 
84
            if 'reconnect_interval' in options:
 
85
                retry_registration(options['reconnect_interval'], base)
 
86
 
 
87
 
 
88
def clear_db(base=BASE):
82
89
    global _ENGINE
83
90
    assert _ENGINE
84
 
    for table in reversed(BASE.metadata.sorted_tables):
 
91
    for table in reversed(base.metadata.sorted_tables):
85
92
        _ENGINE.execute(table.delete())
86
93
 
87
94
 
96
103
    return _MAKER()
97
104
 
98
105
 
99
 
def register_models():
 
106
def retry_registration(reconnect_interval, base=BASE):
 
107
    while True:
 
108
        LOG.info("Unable to connect to database. Retrying in %s seconds" %
 
109
                 reconnect_interval)
 
110
        time.sleep(reconnect_interval)
 
111
        if register_models(base):
 
112
            break
 
113
 
 
114
 
 
115
def register_models(base=BASE):
100
116
    """Register Models and create properties"""
101
117
    global _ENGINE
102
118
    assert _ENGINE
103
 
    BASE.metadata.create_all(_ENGINE)
104
 
 
105
 
 
106
 
def unregister_models():
 
119
    try:
 
120
        base.metadata.create_all(_ENGINE)
 
121
    except sql.exc.OperationalError as e:
 
122
        LOG.info("Database registration exception: %s" % e)
 
123
        return False
 
124
    return True
 
125
 
 
126
 
 
127
def unregister_models(base=BASE):
107
128
    """Unregister Models, useful clearing out data before testing"""
108
129
    global _ENGINE
109
130
    assert _ENGINE
110
 
    BASE.metadata.drop_all(_ENGINE)
 
131
    base.metadata.drop_all(_ENGINE)
111
132
 
112
133
 
113
134
def network_create(tenant_id, name, op_status=OperationalStatus.UNKNOWN):
127
148
 
128
149
def network_list(tenant_id):
129
150
    session = get_session()
130
 
    return session.query(models.Network).\
131
 
      filter_by(tenant_id=tenant_id).\
132
 
      all()
 
151
    return (session.query(models.Network).
 
152
            filter_by(tenant_id=tenant_id).
 
153
            all())
133
154
 
134
155
 
135
156
def network_get(net_id):
136
157
    session = get_session()
137
158
    try:
138
 
        return  session.query(models.Network).\
139
 
            filter_by(uuid=net_id).\
140
 
            one()
141
 
    except exc.NoResultFound, e:
 
159
        return (session.query(models.Network).
 
160
                filter_by(uuid=net_id).
 
161
                one())
 
162
    except exc.NoResultFound:
142
163
        raise q_exc.NetworkNotFound(net_id=net_id)
143
164
 
144
165
 
155
176
def network_destroy(net_id):
156
177
    session = get_session()
157
178
    try:
158
 
        net = session.query(models.Network).\
159
 
          filter_by(uuid=net_id).\
160
 
          one()
 
179
        net = (session.query(models.Network).
 
180
               filter_by(uuid=net_id).
 
181
               one())
161
182
 
162
 
        ports = session.query(models.Port).\
163
 
            filter_by(network_id=net_id).\
164
 
            all()
 
183
        ports = (session.query(models.Port).
 
184
                 filter_by(network_id=net_id).
 
185
                 all())
165
186
        for p in ports:
166
187
            session.delete(p)
167
188
 
175
196
def validate_network_ownership(tenant_id, net_id):
176
197
    session = get_session()
177
198
    try:
178
 
        return  session.query(models.Network).\
179
 
            filter_by(uuid=net_id).\
180
 
            filter_by(tenant_id=tenant_id).\
181
 
            one()
182
 
    except exc.NoResultFound, e:
 
199
        return (session.query(models.Network).
 
200
                filter_by(uuid=net_id).
 
201
                filter_by(tenant_id=tenant_id).
 
202
                one())
 
203
    except exc.NoResultFound:
183
204
        raise q_exc.NetworkNotFound(net_id=net_id)
184
205
 
185
206
 
204
225
    # confirm network exists
205
226
    network_get(net_id)
206
227
    session = get_session()
207
 
    return session.query(models.Port).\
208
 
      filter_by(network_id=net_id).\
209
 
      all()
 
228
    return (session.query(models.Port).
 
229
            filter_by(network_id=net_id).
 
230
            all())
210
231
 
211
232
 
212
233
def port_get(port_id, net_id, session=None):
215
236
    if not session:
216
237
        session = get_session()
217
238
    try:
218
 
        return session.query(models.Port).\
219
 
          filter_by(uuid=port_id).\
220
 
          filter_by(network_id=net_id).\
221
 
          one()
 
239
        return (session.query(models.Port).
 
240
                filter_by(uuid=port_id).
 
241
                filter_by(network_id=net_id).
 
242
                one())
222
243
    except exc.NoResultFound:
223
244
        raise q_exc.PortNotFound(net_id=net_id, port_id=port_id)
224
245
 
228
249
    network_get(net_id)
229
250
    port = port_get(port_id, net_id)
230
251
    session = get_session()
231
 
    for key in kwargs.keys():
 
252
    for key in kwargs:
232
253
        if key == "state":
233
254
            if kwargs[key] not in ('ACTIVE', 'DOWN'):
234
255
                raise q_exc.StateInvalid(port_state=kwargs[key])
249
270
        # We are setting, not clearing, the attachment-id
250
271
        if port['interface_id']:
251
272
            raise q_exc.PortInUse(net_id=net_id, port_id=port_id,
252
 
                                att_id=port['interface_id'])
 
273
                                  att_id=port['interface_id'])
253
274
 
254
275
        try:
255
 
            port = session.query(models.Port).\
256
 
            filter_by(interface_id=new_interface_id).\
257
 
            one()
 
276
            port = (session.query(models.Port).
 
277
                    filter_by(interface_id=new_interface_id).
 
278
                    one())
258
279
            raise q_exc.AlreadyAttached(net_id=net_id,
259
 
                                    port_id=port_id,
260
 
                                    att_id=new_interface_id,
261
 
                                    att_port_id=port['uuid'])
 
280
                                        port_id=port_id,
 
281
                                        att_id=new_interface_id,
 
282
                                        att_port_id=port['uuid'])
262
283
        except exc.NoResultFound:
263
284
            # this is what should happen
264
285
            pass
285
306
 
286
307
    session = get_session()
287
308
    try:
288
 
        port = session.query(models.Port).\
289
 
          filter_by(uuid=port_id).\
290
 
          filter_by(network_id=net_id).\
291
 
          one()
 
309
        port = (session.query(models.Port).
 
310
                filter_by(uuid=port_id).
 
311
                filter_by(network_id=net_id).
 
312
                one())
292
313
        if port['interface_id']:
293
314
            raise q_exc.PortInUse(net_id=net_id, port_id=port_id,
294
 
                                att_id=port['interface_id'])
 
315
                                  att_id=port['interface_id'])
295
316
        session.delete(port)
296
317
        session.flush()
297
318
        return port