Grzegorz Grasza
db9ddd39d3
During a rolling upgrade, ironic conductor and api services are running with different versions. When an object is received in an incompatible version, IncompatibleObjectVersion is raised. Implementation of the indirection API allows the object to be backported to a supported version by the conductor (conductor has to be the first service to be upgraded). This change enables backporting of objects from Mitaka. This lays the foundation to be able to do rolling upgrades from Liberty (or from this patch onwards) to Mitaka. There may still be other issues that will need fixing in Mitaka before we will be able to do a full rolling upgrade. Enabling the indirection_api causes all object methods decorated with the remotable or remotable_classmethod to do RPC from ironic-api to ironic-conductor service. To keep the current behavior, I'm removing all remotable decorators on object methods and thus not enabling object RPC calls in this patch. These calls caused random timeouts on the CI gates (probably due to a race in which Nova calls the ironic-api service before ironic-conductor is up). RPC calls made via the indirection_api should be enabled one-by-one, when the implications are fully understood. Change-Id: Ia381348da93f95d764c83f3ec2a2ed5a1db5ad6d Closes-Bug: 1493816 Depends-On: I81400305f166d62aa4612aab54602abb8178b64c
213 lines
9.1 KiB
Python
213 lines
9.1 KiB
Python
# coding=utf-8
|
|
#
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from oslo_utils import strutils
|
|
from oslo_utils import uuidutils
|
|
from oslo_versionedobjects import base as object_base
|
|
|
|
from ironic.common import exception
|
|
from ironic.db import api as dbapi
|
|
from ironic.objects import base
|
|
from ironic.objects import fields as object_fields
|
|
|
|
|
|
@base.IronicObjectRegistry.register
|
|
class Chassis(base.IronicObject, object_base.VersionedObjectDictCompat):
|
|
# Version 1.0: Initial version
|
|
# Version 1.1: Add get() and get_by_id() and make get_by_uuid()
|
|
# only work with a uuid
|
|
# Version 1.2: Add create() and destroy()
|
|
# Version 1.3: Add list()
|
|
VERSION = '1.3'
|
|
|
|
dbapi = dbapi.get_instance()
|
|
|
|
fields = {
|
|
'id': object_fields.IntegerField(),
|
|
'uuid': object_fields.UUIDField(nullable=True),
|
|
'extra': object_fields.FlexibleDictField(nullable=True),
|
|
'description': object_fields.StringField(nullable=True),
|
|
}
|
|
|
|
@staticmethod
|
|
def _from_db_object(chassis, db_chassis):
|
|
"""Converts a database entity to a formal :class:`Chassis` object.
|
|
|
|
:param chassis: An object of :class:`Chassis`.
|
|
:param db_chassis: A DB model of a chassis.
|
|
:return: a :class:`Chassis` object.
|
|
"""
|
|
for field in chassis.fields:
|
|
chassis[field] = db_chassis[field]
|
|
|
|
chassis.obj_reset_changes()
|
|
return chassis
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable_classmethod
|
|
@classmethod
|
|
def get(cls, context, chassis_id):
|
|
"""Find a chassis based on its id or uuid and return a Chassis object.
|
|
|
|
:param chassis_id: the id *or* uuid of a chassis.
|
|
:returns: a :class:`Chassis` object.
|
|
"""
|
|
if strutils.is_int_like(chassis_id):
|
|
return cls.get_by_id(context, chassis_id)
|
|
elif uuidutils.is_uuid_like(chassis_id):
|
|
return cls.get_by_uuid(context, chassis_id)
|
|
else:
|
|
raise exception.InvalidIdentity(identity=chassis_id)
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable_classmethod
|
|
@classmethod
|
|
def get_by_id(cls, context, chassis_id):
|
|
"""Find a chassis based on its integer id and return a Chassis object.
|
|
|
|
:param chassis_id: the id of a chassis.
|
|
:returns: a :class:`Chassis` object.
|
|
"""
|
|
db_chassis = cls.dbapi.get_chassis_by_id(chassis_id)
|
|
chassis = Chassis._from_db_object(cls(context), db_chassis)
|
|
return chassis
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable_classmethod
|
|
@classmethod
|
|
def get_by_uuid(cls, context, uuid):
|
|
"""Find a chassis based on uuid and return a :class:`Chassis` object.
|
|
|
|
:param uuid: the uuid of a chassis.
|
|
:param context: Security context
|
|
:returns: a :class:`Chassis` object.
|
|
"""
|
|
db_chassis = cls.dbapi.get_chassis_by_uuid(uuid)
|
|
chassis = Chassis._from_db_object(cls(context), db_chassis)
|
|
return chassis
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable_classmethod
|
|
@classmethod
|
|
def list(cls, context, limit=None, marker=None,
|
|
sort_key=None, sort_dir=None):
|
|
"""Return a list of Chassis objects.
|
|
|
|
:param context: Security context.
|
|
:param limit: maximum number of resources to return in a single result.
|
|
:param marker: pagination marker for large data sets.
|
|
:param sort_key: column to sort results by.
|
|
:param sort_dir: direction to sort. "asc" or "desc".
|
|
:returns: a list of :class:`Chassis` object.
|
|
|
|
"""
|
|
db_chassis = cls.dbapi.get_chassis_list(limit=limit,
|
|
marker=marker,
|
|
sort_key=sort_key,
|
|
sort_dir=sort_dir)
|
|
return [Chassis._from_db_object(cls(context), obj)
|
|
for obj in db_chassis]
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable
|
|
def create(self, context=None):
|
|
"""Create a Chassis record in the DB.
|
|
|
|
Column-wise updates will be made based on the result of
|
|
self.what_changed(). If target_power_state is provided,
|
|
it will be checked against the in-database copy of the
|
|
chassis before updates are made.
|
|
|
|
:param context: Security context. NOTE: This should only
|
|
be used internally by the indirection_api.
|
|
Unfortunately, RPC requires context as the first
|
|
argument, even though we don't use it.
|
|
A context should be set when instantiating the
|
|
object, e.g.: Chassis(context)
|
|
|
|
"""
|
|
values = self.obj_get_changes()
|
|
db_chassis = self.dbapi.create_chassis(values)
|
|
self._from_db_object(self, db_chassis)
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable
|
|
def destroy(self, context=None):
|
|
"""Delete the Chassis from the DB.
|
|
|
|
:param context: Security context. NOTE: This should only
|
|
be used internally by the indirection_api.
|
|
Unfortunately, RPC requires context as the first
|
|
argument, even though we don't use it.
|
|
A context should be set when instantiating the
|
|
object, e.g.: Chassis(context)
|
|
"""
|
|
self.dbapi.destroy_chassis(self.uuid)
|
|
self.obj_reset_changes()
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable
|
|
def save(self, context=None):
|
|
"""Save updates to this Chassis.
|
|
|
|
Updates will be made column by column based on the result
|
|
of self.what_changed().
|
|
|
|
:param context: Security context. NOTE: This should only
|
|
be used internally by the indirection_api.
|
|
Unfortunately, RPC requires context as the first
|
|
argument, even though we don't use it.
|
|
A context should be set when instantiating the
|
|
object, e.g.: Chassis(context)
|
|
"""
|
|
updates = self.obj_get_changes()
|
|
updated_chassis = self.dbapi.update_chassis(self.uuid, updates)
|
|
self._from_db_object(self, updated_chassis)
|
|
|
|
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
|
|
# methods can be used in the future to replace current explicit RPC calls.
|
|
# Implications of calling new remote procedures should be thought through.
|
|
# @object_base.remotable
|
|
def refresh(self, context=None):
|
|
"""Loads and applies updates for this Chassis.
|
|
|
|
Loads a :class:`Chassis` with the same uuid from the database and
|
|
checks for updated attributes. Updates are applied from
|
|
the loaded chassis column by column, if there are any updates.
|
|
|
|
:param context: Security context. NOTE: This should only
|
|
be used internally by the indirection_api.
|
|
Unfortunately, RPC requires context as the first
|
|
argument, even though we don't use it.
|
|
A context should be set when instantiating the
|
|
object, e.g.: Chassis(context)
|
|
"""
|
|
current = self.__class__.get_by_uuid(self._context, uuid=self.uuid)
|
|
self.obj_refresh(current)
|