예제 #1
0
    def handle_cluster_startup(self):
        i = 0
        consul_api = ConsulAPI()
        logger.debug("Check cluster startup.")
        while True:
            try:

                current_node_name = self.__node_info.name
                result = consul_api.set_leader_startup_time(
                    current_node_name, str(i))
                if i == 0 and not result:
                    sleep(2)
                    continue
                elif result:
                    # value returned, consul is up and running
                    sleep(2)
                    number_of_started_nodes = 0
                    for kv in consul_api.get_leaders_startup_times():
                        node_name = str(kv.Key).replace(
                            ConfigAPI().get_consul_leaders_path(), "")
                        if node_name != current_node_name:
                            if int(kv.Value) == 0:
                                number_of_started_nodes += 1

                    logger.debug("Number of started nodes = {}.".format(
                        number_of_started_nodes))
                    # Another management node is just starting
                    if i == 0 and number_of_started_nodes > 0:
                        logger.info(
                            "Cluster is just starting, system will delete all active disk resources"
                        )
                        consul_api.delete_disk(
                            ConfigAPI().get_consul_disks_path(), recurse=True)
                i += 1
                sleep(58)

            except Exception as ex:
                logger.debug("Start up error")
                logger.exception(ex)
                # maybe other management nodes are starting, give them a chance to start
                if i == 0:
                    sleep(2)
                else:
                    i += 1
                    sleep(58)
예제 #2
0
    def __stop_disk(self, disk_id):
        consul_api = ConsulAPI()
        ceph_api = CephAPI()
        lio_api = LioAPI()
        network_api = NetworkAPI()
        logger.info("Stopping disk %s" % disk_id)
        image_name = self.__image_name_prefix + str(disk_id)

        try:
            # Get iqn.
            #iqn = ceph_api.get_disk_meta(disk_id, pool).iqn
            iqn = self._get_iqn_by_disk(disk_id)
            # Get tpgs for iqn.
            tpgs = self.__iqn_tpgs.get(iqn, None)
            if not iqn or not tpgs or len(tpgs) == 0:
                logger.error("Could not find ips for %s " % image_name)
            # Remove the assigned ips from our interfaces
            elif tpgs and len(tpgs) > 0:
                # Get assigned ips for each path.
                for tpg, ips in tpgs.iteritems():
                    for ip in ips:
                        if not network_api.delete_ip(
                                ip, self.__cluster_info.iscsi_1_eth_name):
                            network_api.delete_ip(
                                ip, self.__cluster_info.iscsi_2_eth_name)

            lio_api.delete_target(image_name, iqn)
            ceph_api.unmap_image(image_name)
            sleep(2)
            pool = self._get_pool_by_disk(disk_id)
            if not pool:
                logger.error('Could not find pool for disk ' + disk_id)
                return
            if not ceph_api.is_image_busy(image_name, pool):
                consul_api.delete_disk(
                    self.__app_conf.get_consul_disks_path() + disk_id, None,
                    True)
                logger.info(
                    "PetaSAN removed key of stopped disk {} from consul.".
                    format(disk_id))
        except Exception as e:
            logger.info("Could not stop  disk %s" % disk_id)
        return