← Back to branch summary

~rohitagarwalla/neutron/l2network-plugin-db

« back to all changes in this revision

Viewing changes to quantum/plugins/cisco/db/l2network_db.py

  • Committer: rohitagarwalla
  • Date: 2011-08-10 19:39:09 UTC
  • Revision ID: roagarwa@cisco.com-20110810193909-571td6omgrlezh8r
- added network and port models into the l2network plugin instead of using quantum models
- added api methods for network and ports
- restructured code to use the l2network network and port
- added l2network base class for other tables to inherit
- added support for l2network plugin model objects to behave like dictionary (gets rid of code to convert objects into dictionaries)
- added foreign key constraints to l2network plugin model attributes representing columns
- added attributes to represent relation between models in l2network plugin
- added joinedload only to network and port (need to to for others)
- added InnoDB as the storage medium in base table for imposing foreign keys
- updated l2network test cases to handle foreign key constraints

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantum/plugins/cisco/db/l2network_db.py
15
15
#    under the License.
16
16
# @author: Rohit Agarwalla, Cisco Systems, Inc.
17
17
 
18
 
from sqlalchemy.orm import exc
 
18
from sqlalchemy import create_engine
 
19
from sqlalchemy.orm import sessionmaker, exc, joinedload
19
20
 
20
21
import l2network_models
21
 
import quantum.db.api as db
22
 
import quantum.db.models as models
 
22
 
 
23
 
 
24
from quantum.common import exceptions as q_exc
 
25
 
 
26
 
 
27
_ENGINE = None
 
28
_MAKER = None
 
29
BASE = l2network_models.BASE
 
30
 
 
31
 
 
32
def configure_db(options):
 
33
    """
 
34
    Establish the database, create an engine if needed, and
 
35
    register the models.
 
36
 
 
37
    :param options: Mapping of configuration options
 
38
    """
 
39
    global _ENGINE
 
40
    if not _ENGINE:
 
41
        _ENGINE = create_engine(options['sql_connection'],
 
42
                                echo=False,
 
43
                                echo_pool=True,
 
44
                                pool_recycle=3600)
 
45
        register_models()
 
46
 
 
47
 
 
48
def clear_db():
 
49
    global _ENGINE
 
50
    assert _ENGINE
 
51
    for table in reversed(BASE.metadata.sorted_tables):
 
52
        _ENGINE.execute(table.delete())
 
53
 
 
54
 
 
55
def get_session(autocommit=True, expire_on_commit=False):
 
56
    """Helper method to grab session"""
 
57
    global _MAKER, _ENGINE
 
58
    if not _MAKER:
 
59
        assert _ENGINE
 
60
        _MAKER = sessionmaker(bind=_ENGINE,
 
61
                              autocommit=autocommit,
 
62
                              expire_on_commit=expire_on_commit)
 
63
    return _MAKER()
 
64
 
 
65
 
 
66
def register_models():
 
67
    """Register Models and create properties"""
 
68
    global _ENGINE
 
69
    assert _ENGINE
 
70
    BASE.metadata.create_all(_ENGINE)
 
71
 
 
72
 
 
73
def unregister_models():
 
74
    """Unregister Models, useful clearing out data before testing"""
 
75
    global _ENGINE
 
76
    assert _ENGINE
 
77
    BASE.metadata.drop_all(_ENGINE)
 
78
 
 
79
 
 
80
def _check_duplicate_net_name(tenant_id, net_name):
 
81
    session = get_session()
 
82
    try:
 
83
        net = session.query(l2network_models.Network).\
 
84
          filter_by(tenant_id=tenant_id, name=net_name).\
 
85
          one()
 
86
        raise q_exc.NetworkNameExists(tenant_id=tenant_id,
 
87
                        net_name=net_name, net_id=net.uuid)
 
88
    except exc.NoResultFound:
 
89
        # this is the "normal" path, as API spec specifies
 
90
        # that net-names are unique within a tenant
 
91
        pass
 
92
 
 
93
 
 
94
def network_create(tenant_id, name):
 
95
    session = get_session()
 
96
 
 
97
    _check_duplicate_net_name(tenant_id, name)
 
98
    with session.begin():
 
99
        net = l2network_models.Network(tenant_id, name)
 
100
        session.add(net)
 
101
        session.flush()
 
102
        return net
 
103
 
 
104
 
 
105
def network_list(tenant_id):
 
106
    session = get_session()
 
107
    return session.query(l2network_models.Network).\
 
108
      options(joinedload(l2network_models.Network.ports)). \
 
109
      filter_by(tenant_id=tenant_id).\
 
110
      all()
 
111
 
 
112
 
 
113
def network_get(net_id):
 
114
    session = get_session()
 
115
    try:
 
116
        return  session.query(l2network_models.Network).\
 
117
            filter_by(uuid=net_id).\
 
118
            one()
 
119
    except exc.NoResultFound, e:
 
120
        raise q_exc.NetworkNotFound(net_id=net_id)
 
121
 
 
122
 
 
123
def network_rename(net_id, tenant_id, new_name):
 
124
    session = get_session()
 
125
    net = network_get(net_id)
 
126
    _check_duplicate_net_name(tenant_id, new_name)
 
127
    net.name = new_name
 
128
    session.merge(net)
 
129
    session.flush()
 
130
    return net
 
131
 
 
132
 
 
133
def network_destroy(net_id):
 
134
    session = get_session()
 
135
    try:
 
136
        net = session.query(l2network_models.Network).\
 
137
          filter_by(uuid=net_id).\
 
138
          one()
 
139
        session.delete(net)
 
140
        session.flush()
 
141
        return net
 
142
    except exc.NoResultFound:
 
143
        raise q_exc.NetworkNotFound(net_id=net_id)
 
144
 
 
145
 
 
146
def port_create(net_id, state=None):
 
147
    # confirm network exists
 
148
    network_get(net_id)
 
149
 
 
150
    session = get_session()
 
151
    with session.begin():
 
152
        port = l2network_models.Port(net_id)
 
153
        port['state'] = state or 'DOWN'
 
154
        session.add(port)
 
155
        session.flush()
 
156
        return port
 
157
 
 
158
 
 
159
def port_list(net_id):
 
160
    session = get_session()
 
161
    return session.query(l2network_models.Port).\
 
162
      options(joinedload(l2network_models.Port.network)). \
 
163
      filter_by(network_id=net_id).\
 
164
      all()
 
165
 
 
166
 
 
167
def port_get(port_id, net_id):
 
168
    # confirm network exists
 
169
    network_get(net_id)
 
170
    session = get_session()
 
171
    try:
 
172
        return  session.query(l2network_models.Port).\
 
173
          filter_by(uuid=port_id).\
 
174
          filter_by(network_id=net_id).\
 
175
          one()
 
176
    except exc.NoResultFound:
 
177
        raise q_exc.PortNotFound(net_id=net_id, port_id=port_id)
 
178
 
 
179
 
 
180
def port_set_state(port_id, net_id, new_state):
 
181
    if new_state not in ('ACTIVE', 'DOWN'):
 
182
        raise q_exc.StateInvalid(port_state=new_state)
 
183
 
 
184
    # confirm network exists
 
185
    network_get(net_id)
 
186
 
 
187
    port = port_get(port_id, net_id)
 
188
    session = get_session()
 
189
    port.state = new_state
 
190
    session.merge(port)
 
191
    session.flush()
 
192
    return port
 
193
 
 
194
 
 
195
def port_set_attachment(port_id, net_id, new_interface_id):
 
196
    # confirm network exists
 
197
    network_get(net_id)
 
198
 
 
199
    session = get_session()
 
200
    port = port_get(port_id, net_id)
 
201
 
 
202
    if new_interface_id != "":
 
203
        # We are setting, not clearing, the attachment-id
 
204
        if port['interface_id']:
 
205
            raise q_exc.PortInUse(net_id=net_id, port_id=port_id,
 
206
                                att_id=port['interface_id'])
 
207
 
 
208
        try:
 
209
            port = session.query(l2network_models.Port).\
 
210
            filter_by(interface_id=new_interface_id).\
 
211
            one()
 
212
            raise q_exc.AlreadyAttached(net_id=net_id,
 
213
                                    port_id=port_id,
 
214
                                    att_id=new_interface_id,
 
215
                                    att_port_id=port['uuid'])
 
216
        except exc.NoResultFound:
 
217
            # this is what should happen
 
218
            pass
 
219
    port.interface_id = new_interface_id
 
220
    session.merge(port)
 
221
    session.flush()
 
222
    return port
 
223
 
 
224
 
 
225
def port_unset_attachment(port_id, net_id):
 
226
    # confirm network exists
 
227
    network_get(net_id)
 
228
 
 
229
    session = get_session()
 
230
    port = port_get(port_id, net_id)
 
231
    port.interface_id = None
 
232
    session.merge(port)
 
233
    session.flush()
 
234
 
 
235
 
 
236
def port_destroy(port_id, net_id):
 
237
    # confirm network exists
 
238
    network_get(net_id)
 
239
 
 
240
    session = get_session()
 
241
    try:
 
242
        port = session.query(l2network_models.Port).\
 
243
          filter_by(uuid=port_id).\
 
244
          filter_by(network_id=net_id).\
 
245
          one()
 
246
        if port['interface_id']:
 
247
            raise q_exc.PortInUse(net_id=net_id, port_id=port_id,
 
248
                                att_id=port['interface_id'])
 
249
        session.delete(port)
 
250
        session.flush()
 
251
        return port
 
252
    except exc.NoResultFound:
 
253
        raise q_exc.PortNotFound(port_id=port_id)
23
254
 
24
255
 
25
256
def get_all_vlan_bindings():
26
257
    """Lists all the vlan to network associations"""
27
 
    session = db.get_session()
 
258
    session = get_session()
28
259
    try:
29
260
        bindings = session.query(l2network_models.VlanBinding).\
30
261
          all()
35
266
 
36
267
def get_vlan_binding(netid):
37
268
    """Lists the vlan given a network_id"""
38
 
    session = db.get_session()
 
269
    session = get_session()
39
270
    try:
40
271
        binding = session.query(l2network_models.VlanBinding).\
41
272
          filter_by(network_id=netid).\
47
278
 
48
279
def add_vlan_binding(vlanid, vlanname, netid):
49
280
    """Adds a vlan to network association"""
50
 
    session = db.get_session()
 
281
    session = get_session()
51
282
    try:
52
283
        binding = session.query(l2network_models.VlanBinding).\
53
284
          filter_by(vlan_id=vlanid).\
62
293
 
63
294
def remove_vlan_binding(netid):
64
295
    """Removes a vlan to network association"""
65
 
    session = db.get_session()
 
296
    session = get_session()
66
297
    try:
67
298
        binding = session.query(l2network_models.VlanBinding).\
68
299
          filter_by(network_id=netid).\
76
307
 
77
308
def update_vlan_binding(netid, newvlanid=None, newvlanname=None):
78
309
    """Updates a vlan to network association"""
79
 
    session = db.get_session()
 
310
    session = get_session()
80
311
    try:
81
312
        binding = session.query(l2network_models.VlanBinding).\
82
313
          filter_by(network_id=netid).\
83
314
          one()
84
315
        if newvlanid:
85
 
            binding.vlan_id = newvlanid
 
316
            binding["vlan_id"] = newvlanid
86
317
        if newvlanname:
87
 
            binding.vlan_name = newvlanname
 
318
            binding["vlan_name"] = newvlanname
88
319
        session.merge(binding)
89
320
        session.flush()
90
321
        return binding
94
325
 
95
326
def get_all_portprofiles():
96
327
    """Lists all the port profiles"""
97
 
    session = db.get_session()
 
328
    session = get_session()
98
329
    try:
99
330
        pps = session.query(l2network_models.PortProfile).\
100
331
          all()
105
336
 
106
337
def get_portprofile(ppid):
107
338
    """Lists a port profile"""
108
 
    session = db.get_session()
 
339
    session = get_session()
109
340
    try:
110
341
        pp = session.query(l2network_models.PortProfile).\
111
342
          filter_by(uuid=ppid).\
117
348
 
118
349
def add_portprofile(ppname, vlanid, qos):
119
350
    """Adds a port profile"""
120
 
    session = db.get_session()
 
351
    session = get_session()
121
352
    try:
122
353
        pp = session.query(l2network_models.PortProfile).\
123
354
          filter_by(name=ppname).\
132
363
 
133
364
def remove_portprofile(ppid):
134
365
    """Removes a port profile"""
135
 
    session = db.get_session()
 
366
    session = get_session()
136
367
    try:
137
368
        pp = session.query(l2network_models.PortProfile).\
138
369
          filter_by(uuid=ppid).\
146
377
 
147
378
def update_portprofile(ppid, newppname=None, newvlanid=None, newqos=None):
148
379
    """Updates port profile"""
149
 
    session = db.get_session()
 
380
    session = get_session()
150
381
    try:
151
382
        pp = session.query(l2network_models.PortProfile).\
152
383
          filter_by(uuid=ppid).\
153
384
          one()
154
385
        if newppname:
155
 
            pp.name = newppname
 
386
            pp["name"] = newppname
156
387
        if newvlanid:
157
 
            pp.vlan_id = newvlanid
 
388
            pp["vlan_id"] = newvlanid
158
389
        if newqos:
159
 
            pp.qos = newqos
 
390
            pp["qos"] = newqos
160
391
        session.merge(pp)
161
392
        session.flush()
162
393
        return pp
166
397
 
167
398
def get_all_pp_bindings():
168
399
    """Lists all the port profiles"""
169
 
    session = db.get_session()
 
400
    session = get_session()
170
401
    try:
171
402
        bindings = session.query(l2network_models.PortProfileBinding).\
172
403
          all()
177
408
 
178
409
def get_pp_binding(ppid):
179
410
    """Lists a port profile binding"""
180
 
    session = db.get_session()
 
411
    session = get_session()
181
412
    try:
182
413
        binding = session.query(l2network_models.PortProfileBinding).\
183
414
          filter_by(portprofile_id=ppid).\
189
420
 
190
421
def add_pp_binding(tenantid, networkid, ppid, default):
191
422
    """Adds a port profile binding"""
192
 
    session = db.get_session()
 
423
    session = get_session()
193
424
    try:
194
425
        binding = session.query(l2network_models.PortProfileBinding).\
195
426
          filter_by(portprofile_id=ppid).\
206
437
 
207
438
def remove_pp_binding(ppid):
208
439
    """Removes a port profile binding"""
209
 
    session = db.get_session()
 
440
    session = get_session()
210
441
    try:
211
442
        binding = session.query(l2network_models.PortProfileBinding).\
212
443
          filter_by(portprofile_id=ppid).\
221
452
def update_pp_binding(ppid, newtenantid=None, newnetworkid=None, \
222
453
                                                    newdefault=None):
223
454
    """Updates port profile binding"""
224
 
    session = db.get_session()
 
455
    session = get_session()
225
456
    try:
226
457
        binding = session.query(l2network_models.PortProfileBinding).\
227
458
          filter_by(portprofile_id=ppid).\
228
459
          one()
229
460
        if newtenantid:
230
 
            binding.tenant_id = newtenantid
 
461
            binding["tenant_id"] = newtenantid
231
462
        if newnetworkid:
232
 
            binding.network_id = newnetworkid
 
463
            binding["network_id"] = newnetworkid
233
464
        if newdefault:
234
 
            binding.default = newdefault
 
465
            binding["default"] = newdefault
235
466
        session.merge(binding)
236
467
        session.flush()
237
468
        return binding