trove taskmanger api

trove-taskmanager服务在配置实例，管理实例的生命周期以及对数据库实例执行操作方面做了很多工作。
taskmanager会通过Nova、Swift的API访问Openstack基础的服务，而且是有状态的，是整个系统的核心。
本文通过trove api的代码，来解读taskmanger所具有的功能
 
from oslo_log import log as logging
import oslo_messaging as messaging
 
from trove.common import cfg
from trove.common import exception
from trove.common.notification import NotificationCastWrapper
import trove.common.rpc.version as rpc_version
from trove.common.strategies.cluster import strategy
from trove.guestagent import models as agent_models
from trove import rpc
 
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
 
class API(object):
    """API for interacting with the task manager."""
 
    def __init__(self, context):
        self.context = context
        super(API, self).__init__()
 
        target = messaging.Target(topic=CONF.taskmanager_queue,
                                  version=rpc_version.RPC_API_VERSION)
 
        self.version_cap = rpc_version.VERSION_ALIASES.get(
            CONF.upgrade_levels.taskmanager)
        self.client = self.get_client(target, self.version_cap)
 
    def _cast(self, method_name, version, **kwargs):
        LOG.debug("Casting %s" % method_name)
        with NotificationCastWrapper(self.context, 'taskmanager'):
            cctxt = self.client.prepare(version=version)
            cctxt.cast(self.context, method_name, **kwargs)
 
    def get_client(self, target, version_cap, serializer=None):
        return rpc.get_client(target,
                              version_cap=version_cap,
                              serializer=serializer)
 
    def _transform_obj(self, obj_ref):
        # Turn the object into a dictionary and remove the mgr
        if "__dict__" in dir(obj_ref):                       #dir()显示对象的属性  __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
            obj_dict = obj_ref.__dict__
            # We assume manager contains a object due to the *clients
            if obj_dict.get('manager'):
                del obj_dict['manager']
            return obj_dict
        raise ValueError("Could not transform %s" % obj_ref)
 
    def _delete_heartbeat(self, instance_id):                    #删除心跳
        agent_heart_beat = agent_models.AgentHeartBeat()
        try:
            heartbeat = agent_heart_beat.find_by_instance_id(instance_id)
            heartbeat.delete()
        except exception.ModelNotFoundError as e:
            LOG.error(e.message)
 
    def resize_volume(self, new_size, instance_id):             #重新设置卷大小
        LOG.debug("Making async call to resize volume for instance: %s"
                  % instance_id)
 
        self._cast("resize_volume", self.version_cap,
                   new_size=new_size,
                   instance_id=instance_id)
 
    def resize_flavor(self, instance_id, old_flavor, new_flavor):      #重新设置instance的flavor
        LOG.debug("Making async call to resize flavor for instance: %s" %
                  instance_id)
 
        self._cast("resize_flavor", self.version_cap,
                   instance_id=instance_id,
                   old_flavor=self._transform_obj(old_flavor),
                   new_flavor=self._transform_obj(new_flavor))
 
    def reboot(self, instance_id):                                    #重启（instance）
        LOG.debug("Making async call to reboot instance: %s" % instance_id)
 
        self._cast("reboot", self.version_cap, instance_id=instance_id)
 
    def restart(self, instance_id):                                   #重启（数据库）
        LOG.debug("Making async call to restart instance: %s" % instance_id)
 
        self._cast("restart", self.version_cap, instance_id=instance_id)
 
    def detach_replica(self, instance_id):                      #分离副本
        LOG.debug("Making async call to detach replica: %s" % instance_id)
 
        self._cast("detach_replica", self.version_cap,
                   instance_id=instance_id)
 
    def promote_to_replica_source(self, instance_id):           #使副本与来源同步
        LOG.debug("Making async call to promote replica to source: %s" %
                  instance_id)
        self._cast("promote_to_replica_source", self.version_cap,
                   instance_id=instance_id)
 
    def eject_replica_source(self, instance_id):                #弹出复制源
        LOG.debug("Making async call to eject replica source: %s" %
                  instance_id)
        self._cast("eject_replica_source", self.version_cap,
                   instance_id=instance_id)
 
    def migrate(self, instance_id, host):                       #迁移
        LOG.debug("Making async call to migrate instance: %s" % instance_id)
 
        self._cast("migrate", self.version_cap,
                   instance_id=instance_id, host=host)
 
    def delete_instance(self, instance_id):                      #删除instance
        LOG.debug("Making async call to delete instance: %s" % instance_id)
 
        self._cast("delete_instance", self.version_cap,
                   instance_id=instance_id)
 
    def create_backup(self, backup_info, instance_id):           #创建备份
        LOG.debug("Making async call to create a backup for instance: %s" %
                  instance_id)
 
        self._cast("create_backup", self.version_cap,
                   backup_info=backup_info,
                   instance_id=instance_id)
 
    def delete_backup(self, backup_id):                           #删除备份
        LOG.debug("Making async call to delete backup: %s" % backup_id)
 
        self._cast("delete_backup", self.version_cap, backup_id=backup_id)
 
    def create_instance(self, instance_id, name, flavor,        #创建实例
                        image_id, databases, users, datastore_manager,
                        packages, volume_size, backup_id=None,
                        availability_zone=None, root_password=None,
                        nics=None, overrides=None, slave_of_id=None,
                        cluster_config=None, volume_type=None,
                        modules=None, locality=None):
 
        LOG.debug("Making async call to create instance %s " % instance_id)
        self._cast("create_instance", self.version_cap,
                   instance_id=instance_id, name=name,
                   flavor=self._transform_obj(flavor),
                   image_id=image_id,
                   databases=databases,
                   users=users,
                   datastore_manager=datastore_manager,
                   packages=packages,
                   volume_size=volume_size,
                   backup_id=backup_id,
                   availability_zone=availability_zone,
                   root_password=root_password,
                   nics=nics,
                   overrides=overrides,
                   slave_of_id=slave_of_id,
                   cluster_config=cluster_config,
                   volume_type=volume_type,
                   modules=modules, locality=locality)
 
    def create_cluster(self, cluster_id):                      #创建集群
        LOG.debug("Making async call to create cluster %s " % cluster_id)
 
        self._cast("create_cluster", self.version_cap, cluster_id=cluster_id)
 
    def grow_cluster(self, cluster_id, new_instance_ids):       #扩展集群
        LOG.debug("Making async call to grow cluster %s " % cluster_id)
 
        cctxt = self.client.prepare(version=self.version_cap)
        cctxt.cast(self.context, "grow_cluster",
                   cluster_id=cluster_id, new_instance_ids=new_instance_ids)
 
    def shrink_cluster(self, cluster_id, instance_ids):          #收缩
        LOG.debug("Making async call to shrink cluster %s " % cluster_id)
 
        cctxt = self.client.prepare(version=self.version_cap)
        cctxt.cast(self.context, "shrink_cluster",
                   cluster_id=cluster_id, instance_ids=instance_ids)
 
    def delete_cluster(self, cluster_id):                        #删除集群
        LOG.debug("Making async call to delete cluster %s " % cluster_id)
 
        self._cast("delete_cluster", self.version_cap, cluster_id=cluster_id)
 
    def upgrade(self, instance_id, datastore_version_id):           #升级数据库版本
        LOG.debug("Making async call to upgrade guest to datastore "
                  "version %s " % datastore_version_id)
 
        cctxt = self.client.prepare(version=self.version_cap)
        cctxt.cast(self.context, "upgrade", instance_id=instance_id,
                   datastore_version_id=datastore_version_id)
 
def load(context, manager=None):
    if manager:
        task_manager_api_class = (strategy.load_taskmanager_strategy(manager)
                                  .task_manager_api_class)
    else:
        task_manager_api_class = API
    return task_manager_api_class(context)

更多信息：http://www.cnblogs.com/S-tec-songjian/

此文章属博客园用户S-tec原创作品，受国家《著作权法》保护，未经许可，任何单位及个人不得做营利性使用；若仅做个人学习、交流等非营利性使用，应当指明作者姓名、作品名称，原文地址，并且不得侵犯作者依法享有的其他权利。