Python DBInstance.find_all方法代码示例

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
    def test_show_deleted_mgmt_instances(self):
        args = {'deleted': 0, 'cluster_id': None}
        db_infos_active = DBInstance.find_all(**args)
        args = {'deleted': 1, 'cluster_id': None}
        db_infos_deleted = DBInstance.find_all(**args)
        args = {'cluster_id': None}
        # db_infos_all = DBInstance.find_all(**args)

        # TODO(SlickNik) Fix this assert to work reliably in the gate.
        # This fails intermittenly when the unit tests run in parallel.
        # self.assertTrue(db_infos_all.count() ==
        #                 db_infos_active.count() +
        #                 db_infos_deleted.count())

        with patch.object(self.context, 'is_admin', return_value=True):
            deleted_instance = db_infos_deleted.all()[0]
            active_instance = db_infos_active.all()[0]

            instance = DBInstance.find_by(context=self.context,
                                          id=active_instance.id)
            self.assertEqual(active_instance.id, instance.id)

            self.assertRaises(
                exception.ModelNotFoundError,
                DBInstance.find_by,
                context=self.context,
                id=deleted_instance.id,
                deleted=False)

            instance = DBInstance.find_by(context=self.context,
                                          id=deleted_instance.id,
                                          deleted=True)
            self.assertEqual(deleted_instance.id, instance.id)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _add_shard_cluster():

            db_instances = DBInstance.find_all(cluster_id=cluster_id,
                                               shard_id=shard_id).all()
            instance_ids = [db_instance.id for db_instance in db_instances]
            LOG.debug("instances in shard %s: %s" % (shard_id,
                                                     instance_ids))
            if not self._all_instances_ready(instance_ids, cluster_id,
                                             shard_id):
                return

            members = [Instance.load(context, instance_id)
                       for instance_id in instance_ids]

            db_query_routers = DBInstance.find_all(cluster_id=cluster_id,
                                                   type='query_router',
                                                   deleted=False).all()
            query_routers = [Instance.load(context, db_query_router.id)
                             for db_query_router in db_query_routers]

            if not self._create_shard(query_routers[0], members):
                return

            for member in members:
                self.get_guest(member).cluster_complete()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
    def update_statuses_on_failure(self, cluster_id, shard_id=None):

        if CONF.update_status_on_fail:
            if shard_id:
                db_instances = DBInstance.find_all(cluster_id=cluster_id,
                                                   shard_id=shard_id).all()
            else:
                db_instances = DBInstance.find_all(
                    cluster_id=cluster_id).all()

            for db_instance in db_instances:
                db_instance.set_task_status(
                    InstanceTasks.BUILDING_ERROR_SERVER)
                db_instance.save()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _grow_cluster():

            db_instances = DBInstance.find_all(cluster_id=cluster_id).all()
            cluster_head = next(Instance.load(context, db_inst.id)
                                for db_inst in db_instances
                                if db_inst.id not in new_instance_ids)
            if not cluster_head:
                raise TroveError("Unable to determine existing Redis cluster "
                                 "member")

            (cluster_head_ip, cluster_head_port) = (
                self.get_guest(cluster_head).get_node_ip())

            # Wait for cluster members to get to cluster-ready status.
            if not self._all_instances_ready(new_instance_ids, cluster_id):
                return

            LOG.debug("All members ready, proceeding for cluster setup.")
            new_insts = [Instance.load(context, instance_id)
                         for instance_id in new_instance_ids]
            new_guests = map(self.get_guest, new_insts)

            # Connect nodes to the cluster head
            for guest in new_guests:
                guest.cluster_meet(cluster_head_ip, cluster_head_port)

            for guest in new_guests:
                guest.cluster_complete()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _shrink_cluster():
            db_instances = DBInstance.find_all(cluster_id=cluster_id,
                                               deleted=False).all()

            all_instance_ids = [db_instance.id for db_instance in db_instances]

            remove_instances = [Instance.load(context, instance_id)
                                for instance_id in instance_ids]

            left_instances = [Instance.load(context, instance_id)
                              for instance_id
                              in all_instance_ids
                              if instance_id not in instance_ids]

            remove_member_ips = [self.get_ip(instance)
                                 for instance in remove_instances]

            k = VerticaCluster.k_safety(len(left_instances))

            for db_instance in db_instances:
                if db_instance['type'] == 'master':
                    master_instance = Instance.load(context,
                                                    db_instance.id)
                    if self.get_ip(master_instance) in remove_member_ips:
                        raise RuntimeError(_("Cannot remove master instance!"))
                    LOG.debug(_("Marking cluster k-safety: %s") % k)
                    self.get_guest(master_instance).mark_design_ksafe(k)
                    self.get_guest(master_instance).shrink_cluster(
                        remove_member_ips)
                    break

            for r in remove_instances:
                Instance.delete(r)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
 def load(context, id):
     client = create_nova_client(context)
     account = client.accounts.get_instances(id)
     db_infos = DBInstance.find_all(tenant_id=id, deleted=False)
     servers = [Server(server) for server in account.servers]
     instances = MgmtInstances.load_status_from_existing(context, db_infos,
                                                         servers)
     return Account(id, instances)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
 def all_instances_marked_deleted():
     non_deleted_instances = DBInstance.find_all(
         cluster_id=cluster_id, deleted=False).all()
     non_deleted_ids = [db_instance.id for db_instance
                        in non_deleted_instances]
     return not bool(
         set(instance_ids).intersection(set(non_deleted_ids))
     )

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _create_cluster():

            # fetch instances by cluster_id against instances table
            db_instances = DBInstance.find_all(cluster_id=cluster_id).all()
            instance_ids = [db_instance.id for db_instance in db_instances]
            LOG.debug("instances in cluster %s: %s" % (cluster_id,
                                                       instance_ids))

            if not self._all_instances_ready(instance_ids, cluster_id):
                return

            instances = [Instance.load(context, instance_id) for instance_id
                         in instance_ids]

            # filter query routers in instances into a new list: query_routers
            query_routers = [instance for instance in instances if
                             instance.type == 'query_router']
            LOG.debug("query routers: %s" %
                      [instance.id for instance in query_routers])
            # filter config servers in instances into new list: config_servers
            config_servers = [instance for instance in instances if
                              instance.type == 'config_server']
            LOG.debug("config servers: %s" %
                      [instance.id for instance in config_servers])
            # filter members (non router/configsvr) into a new list: members
            members = [instance for instance in instances if
                       instance.type == 'member']
            LOG.debug("members: %s" %
                      [instance.id for instance in members])

            # for config_server in config_servers, append ip/hostname to
            # "config_server_hosts", then
            # peel off the replica-set name and ip/hostname from 'x'
            config_server_ips = [self.get_ip(instance)
                                 for instance in config_servers]
            LOG.debug("config server ips: %s" % config_server_ips)

            LOG.debug("calling add_config_servers on query_routers")
            try:
                for query_router in query_routers:
                    (self.get_guest(query_router)
                     .add_config_servers(config_server_ips))
            except Exception:
                LOG.exception(_("error adding config servers"))
                self.update_statuses_on_failure(cluster_id)
                return

            if not self._create_replica_set(members, cluster_id):
                return

            replica_set_name = "rs1"
            if not self._create_shard(query_routers, replica_set_name,
                                      members, cluster_id):
                return
            # call to start checking status
            for instance in instances:
                self.get_guest(instance).cluster_complete()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
 def _get_cluster_instance_id(self, tenant_id, cluster_id):
     args = {'tenant_id': tenant_id, 'cluster_id': cluster_id}
     cluster_instances = DBInstance.find_all(**args).all()
     instance_ids = [db_instance.id for db_instance in cluster_instances]
     args = {'tenant_id': tenant_id, 'cluster_id': cluster_id, 'type':
             'master'}
     master_instance = DBInstance.find_by(**args)
     master_instance_id = master_instance.id
     return master_instance_id, instance_ids

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
def check_resize(group_id):
    resize = InstanceTasks.RESIZING
    instances = DBInstance.find_all(group_id=group_id,task_id=resize.code())
    insts = list()
    for inst in instances:
        insts.append(inst)
        check_server_status(inst.id)
    return insts
    
    

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
    def update_statuses_on_failure(self, cluster_id):

        if CONF.update_status_on_fail:
            db_instances = DBInstance.find_all(
                cluster_id=cluster_id, deleted=False).all()

            for db_instance in db_instances:
                db_instance.set_task_status(
                    InstanceTasks.BUILDING_ERROR_SERVER)
                db_instance.save()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
 def load(cls):
     # TODO(pdmars): This should probably be changed to a more generic
     # database filter query if one is added, however, this should suffice
     # for now.
     db_infos = DBInstance.find_all(deleted=False)
     tenant_ids_for_instances = [db_info.tenant_id for db_info in db_infos]
     tenant_ids = set(tenant_ids_for_instances)
     LOG.debug("All tenants with instances: %s" % tenant_ids)
     accounts = []
     for tenant_id in tenant_ids:
         num_instances = tenant_ids_for_instances.count(tenant_id)
         accounts.append({'id': tenant_id, 'num_instances': num_instances})
     return cls(accounts)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _create_cluster():

            # fetch instances by cluster_id against instances table
            db_instances = DBInstance.find_all(cluster_id=cluster_id).all()
            instance_ids = [db_instance.id for db_instance in db_instances]
            LOG.debug("instances in cluster %s: %s" % (cluster_id,
                                                       instance_ids))

            if not self._all_instances_ready(instance_ids, cluster_id):
                return

            LOG.debug("all instances in cluster %s ready." % cluster_id)

            instances = [Instance.load(context, instance_id) for instance_id
                         in instance_ids]

            # filter query routers in instances into a new list: query_routers
            query_routers = [instance for instance in instances if
                             instance.type == 'query_router']
            LOG.debug("query routers: %s" %
                      [instance.id for instance in query_routers])
            # filter config servers in instances into new list: config_servers
            config_servers = [instance for instance in instances if
                              instance.type == 'config_server']
            LOG.debug("config servers: %s" %
                      [instance.id for instance in config_servers])
            # filter members (non router/configsvr) into a new list: members
            members = [instance for instance in instances if
                       instance.type == 'member']
            LOG.debug("members: %s" %
                      [instance.id for instance in members])

            # for config_server in config_servers, append ip/hostname to
            # "config_server_hosts", then
            # peel off the replica-set name and ip/hostname from 'x'
            config_server_ips = [self.get_ip(instance)
                                 for instance in config_servers]
            LOG.debug("config server ips: %s" % config_server_ips)

            if not self._add_query_routers(query_routers,
                                           config_server_ips):
                return

            if not self._create_shard(query_routers[0], members):
                return

            # call to start checking status
            for instance in instances:
                self.get_guest(instance).cluster_complete()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
        def _shrink_cluster():
            removal_instances = [Instance.load(context, instance_id)
                                 for instance_id in removal_instance_ids]
            for instance in removal_instances:
                Instance.delete(instance)

            # wait for instances to be deleted
            def all_instances_marked_deleted():
                non_deleted_instances = DBInstance.find_all(
                    cluster_id=cluster_id, deleted=False).all()
                non_deleted_ids = [db_instance.id for db_instance
                                   in non_deleted_instances]
                return not bool(
                    set(removal_instance_ids).intersection(
                        set(non_deleted_ids))
                )
            try:
                LOG.info(_("Deleting instances (%s)") % removal_instance_ids)
                utils.poll_until(all_instances_marked_deleted,
                                 sleep_time=2,
                                 time_out=CONF.cluster_delete_time_out)
            except PollTimeOut:
                LOG.error(_("timeout for instances to be marked as deleted."))
                return

            db_instances = DBInstance.find_all(cluster_id=cluster_id).all()
            leftover_instances = [Instance.load(context, db_inst.id)
                                  for db_inst in db_instances
                                  if db_inst.id not in removal_instance_ids]
            leftover_cluster_ips = [self.get_ip(instance) for instance in
                                    leftover_instances]

            # Get config changes for left over instances
            rnd_cluster_guest = self.get_guest(leftover_instances[0])
            cluster_context = rnd_cluster_guest.get_cluster_context()

            # apply the new config to all leftover instances
            for instance in leftover_instances:
                guest = self.get_guest(instance)
                # render the conf.d/cluster.cnf configuration
                cluster_configuration = self._render_cluster_config(
                    context,
                    instance,
                    ",".join(leftover_cluster_ips),
                    cluster_context['cluster_name'],
                    cluster_context['replication_user'])
                guest.write_cluster_configuration_overrides(
                    cluster_configuration)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import find_all [as 别名]
    def shrink(self, instances):
        """Removes instances from a cluster."""
        LOG.debug("Shrinking cluster %s." % self.id)

        self.validate_cluster_available()
        removal_instances = [Instance.load(self.context, inst_id) for inst_id in instances]
        db_instances = DBInstance.find_all(cluster_id=self.db_info.id).all()
        if len(db_instances) - len(removal_instances) < 1:
            raise exception.ClusterShrinkMustNotLeaveClusterEmpty()

        self.db_info.update(task_status=ClusterTasks.SHRINKING_CLUSTER)
        task_api.load(self.context, self.ds_version.manager).shrink_cluster(
            self.db_info.id, [instance.id for instance in removal_instances]
        )

        return PXCCluster(self.context, self.db_info, self.ds, self.ds_version)