← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ironic/vivid-updates

« back to all changes in this revision

Viewing changes to ironic/db/sqlalchemy/api.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2015-03-30 11:14:57 UTC
  • mfrom: (1.2.6)
  • Revision ID: package-import@ubuntu.com-20150330111457-kr4ju3guf22m4vbz
Tags: 2015.1~b3-0ubuntu1
https://launchpad.net/bugs/1358820
https://launchpad.net/bugs/1429962
* New upstream release.
  + d/control: 
    - Align with upstream dependencies.
    - Add dh-python to build-dependencies.
    - Add psmisc as a dependency. (LP: #1358820)
  + d/p/fix-requirements.patch: Rediffed.
  + d/ironic-conductor.init.in: Fixed typos in LSB headers,
    thanks to JJ Asghar. (LP: #1429962)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ironic/db/sqlalchemy/api.py
19
19
import collections
20
20
import datetime
21
21
 
22
 
from oslo.utils import timeutils
23
22
from oslo_config import cfg
24
23
from oslo_db import exception as db_exc
25
24
from oslo_db.sqlalchemy import session as db_session
26
25
from oslo_db.sqlalchemy import utils as db_utils
 
26
from oslo_utils import strutils
 
27
from oslo_utils import timeutils
 
28
from oslo_utils import uuidutils
27
29
from sqlalchemy.orm.exc import NoResultFound
28
30
 
29
31
from ironic.common import exception
89
91
    :param value: Value for filtering results by.
90
92
    :return: Modified query.
91
93
    """
92
 
    if utils.is_int_like(value):
 
94
    if strutils.is_int_like(value):
93
95
        return query.filter_by(id=value)
94
 
    elif utils.is_uuid_like(value):
 
96
    elif uuidutils.is_uuid_like(value):
95
97
        return query.filter_by(uuid=value)
96
98
    else:
97
99
        raise exception.InvalidIdentity(identity=value)
114
116
 
115
117
 
116
118
def add_port_filter_by_node(query, value):
117
 
    if utils.is_int_like(value):
 
119
    if strutils.is_int_like(value):
118
120
        return query.filter_by(node_id=value)
119
121
    else:
120
122
        query = query.join(models.Node,
123
125
 
124
126
 
125
127
def add_node_filter_by_chassis(query, value):
126
 
    if utils.is_int_like(value):
 
128
    if strutils.is_int_like(value):
127
129
        return query.filter_by(chassis_id=value)
128
130
    else:
129
131
        query = query.join(models.Chassis,
131
133
        return query.filter(models.Chassis.uuid == value)
132
134
 
133
135
 
134
 
def _check_port_change_forbidden(port, session):
135
 
    node_id = port['node_id']
136
 
    if node_id is not None:
137
 
        query = model_query(models.Node, session=session)
138
 
        query = query.filter_by(id=node_id)
139
 
        node_ref = query.one()
140
 
        if node_ref['reservation'] is not None:
141
 
            raise exception.NodeLocked(node=node_ref['uuid'],
142
 
                                       host=node_ref['reservation'])
143
 
 
144
 
 
145
136
def _paginate_query(model, limit=None, marker=None, sort_key=None,
146
137
                    sort_dir=None, query=None):
147
138
    if not query:
189
180
            limit = timeutils.utcnow() - datetime.timedelta(
190
181
                                         seconds=filters['provisioned_before'])
191
182
            query = query.filter(models.Node.provision_updated_at < limit)
 
183
        if 'inspection_started_before' in filters:
 
184
            limit = ((timeutils.utcnow()) -
 
185
                      (datetime.timedelta(
 
186
                       seconds=filters['inspection_started_before'])))
 
187
            query = query.filter(models.Node.inspection_started_at < limit)
192
188
 
193
189
        return query
194
190
 
254
250
    def create_node(self, values):
255
251
        # ensure defaults are present for new nodes
256
252
        if 'uuid' not in values:
257
 
            values['uuid'] = utils.generate_uuid()
 
253
            values['uuid'] = uuidutils.generate_uuid()
258
254
        if 'power_state' not in values:
259
255
            values['power_state'] = states.NOSTATE
260
256
        if 'provision_state' not in values:
266
262
        try:
267
263
            node.save()
268
264
        except db_exc.DBDuplicateEntry as exc:
269
 
            if 'instance_uuid' in exc.columns:
 
265
            if 'name' in exc.columns:
 
266
                raise exception.DuplicateName(name=values['name'])
 
267
            elif 'instance_uuid' in exc.columns:
270
268
                raise exception.InstanceAssociated(
271
269
                    instance_uuid=values['instance_uuid'],
272
270
                    node=values['uuid'])
287
285
        except NoResultFound:
288
286
            raise exception.NodeNotFound(node=node_uuid)
289
287
 
 
288
    def get_node_by_name(self, node_name):
 
289
        query = model_query(models.Node).filter_by(name=node_name)
 
290
        try:
 
291
            return query.one()
 
292
        except NoResultFound:
 
293
            raise exception.NodeNotFound(node=node_name)
 
294
 
290
295
    def get_node_by_instance(self, instance):
291
 
        if not utils.is_uuid_like(instance):
 
296
        if not uuidutils.is_uuid_like(instance):
292
297
            raise exception.InvalidUUID(uuid=instance)
293
298
 
294
299
        query = (model_query(models.Node)
314
319
 
315
320
            # Get node ID, if an UUID was supplied. The ID is
316
321
            # required for deleting all ports, attached to the node.
317
 
            if utils.is_uuid_like(node_id):
 
322
            if uuidutils.is_uuid_like(node_id):
318
323
                node_id = node_ref['id']
319
324
 
320
325
            port_query = model_query(models.Port, session=session)
331
336
 
332
337
        try:
333
338
            return self._do_update_node(node_id, values)
334
 
        except db_exc.DBDuplicateEntry:
335
 
            raise exception.InstanceAssociated(
336
 
                instance_uuid=values['instance_uuid'],
337
 
                node=node_id)
 
339
        except db_exc.DBDuplicateEntry as e:
 
340
            if 'name' in e.columns:
 
341
                raise exception.DuplicateName(name=values['name'])
 
342
            elif 'uuid' in e.columns:
 
343
                raise exception.NodeAlreadyExists(uuid=values['uuid'])
 
344
            elif 'instance_uuid' in e.columns:
 
345
                raise exception.InstanceAssociated(
 
346
                    instance_uuid=values['instance_uuid'],
 
347
                    node=node_id)
 
348
            else:
 
349
                raise e
338
350
 
339
351
    def _do_update_node(self, node_id, values):
340
352
        session = get_session()
353
365
 
354
366
            if 'provision_state' in values:
355
367
                values['provision_updated_at'] = timeutils.utcnow()
 
368
                if values['provision_state'] == states.INSPECTING:
 
369
                    values['inspection_started_at'] = timeutils.utcnow()
 
370
                    values['inspection_finished_at'] = None
 
371
                elif (ref.provision_state == states.INSPECTING and
 
372
                      values['provision_state'] == states.MANAGEABLE):
 
373
                    values['inspection_finished_at'] = timeutils.utcnow()
 
374
                    values['inspection_started_at'] = None
 
375
                elif (ref.provision_state == states.INSPECTING and
 
376
                      values['provision_state'] == states.INSPECTFAIL):
 
377
                    values['inspection_started_at'] = None
356
378
 
357
379
            ref.update(values)
358
380
        return ref
392
414
 
393
415
    def create_port(self, values):
394
416
        if not values.get('uuid'):
395
 
            values['uuid'] = utils.generate_uuid()
 
417
            values['uuid'] = uuidutils.generate_uuid()
396
418
        port = models.Port()
397
419
        port.update(values)
398
420
        try:
427
449
        with session.begin():
428
450
            query = model_query(models.Port, session=session)
429
451
            query = add_port_filter(query, port_id)
430
 
 
431
 
            try:
432
 
                ref = query.one()
433
 
            except NoResultFound:
 
452
            count = query.delete()
 
453
            if count == 0:
434
454
                raise exception.PortNotFound(port=port_id)
435
 
            _check_port_change_forbidden(ref, session)
436
 
 
437
 
            query.delete()
438
455
 
439
456
    def get_chassis_by_id(self, chassis_id):
440
457
        query = model_query(models.Chassis).filter_by(id=chassis_id)
457
474
 
458
475
    def create_chassis(self, values):
459
476
        if not values.get('uuid'):
460
 
            values['uuid'] = utils.generate_uuid()
 
477
            values['uuid'] = uuidutils.generate_uuid()
461
478
        chassis = models.Chassis()
462
479
        chassis.update(values)
463
480
        try: