_deploy.py

# coding: utf-8
# Copyright (c) 2025 OceanBase.
#
# 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 __future__ import absolute_import, division, print_function
from collections.abc import Iterable, Iterator

import os
import re
import sys
import tempfile
import getpass
import hashlib
from copy import deepcopy
from enum import Enum
from datetime import datetime

from ruamel.yaml.comments import CommentedMap

import _errno as err
import const
from _rpm import Version
from tool import ConfigUtil, FileUtil, YamlLoader, OrderedDict, COMMAND_ENV, aes_encrypt, aes_decrypt, \
    string_to_md5_32bytes
from _manager import Manager
from _stdio import SafeStdio
from _environ import ENV_BASE_DIR


yaml = YamlLoader()
DEFAULT_CONFIG_PARSER_MANAGER = None
ENV = 'env'


class ParserError(Exception):
    pass

class ReceiversConfigError(Exception):
    pass


class UserConfig(object):

    DEFAULT = {
        'username': getpass.getuser(),
        'password': None,
        'key_file': None,
        'port': 22,
        'timeout': 300
    }

    def __init__(self, username=None, password=None, key_file=None, port=None, timeout=None):
        self.username = username if username else self.DEFAULT['username']
        self.password = password
        self.key_file = key_file if key_file else self.DEFAULT['key_file']
        self.port = port if port else self.DEFAULT['port']
        self.timeout = timeout if timeout else self.DEFAULT['timeout']

    def __str__(self):
        return '%s' % self.username

    def __repr__(self):
        return '<UserConfig: %s>' % self.__str__()


class ServerConfig(object):

    def __init__(self, ip, name=None):
        self.ip = ip
        self._name = name

    @property
    def name(self):
        return self._name if self._name else self.ip

    def __str__(self):
        return '%s(%s)' % (self._name, self.ip) if self._name else self.ip

    def __repr__(self):
        return '<%s>' % self.__str__()

    def __hash__(self):
        return hash(self.__str__())

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.ip == other.ip and self.name == other.name
        if isinstance(other, dict):
            return self.ip == other['ip'] and self.name == other['name']


class ServerConfigFlyweightFactory(object):

    _CACHE = {}

    @staticmethod
    def get_instance(ip, name=None):
        server = ServerConfig(ip, name)
        _key = server.__str__()
        if _key not in ServerConfigFlyweightFactory._CACHE:
            ServerConfigFlyweightFactory._CACHE[_key] = server
        return ServerConfigFlyweightFactory._CACHE[_key]


class RsyncConfig(object):

    RSYNC = 'runtime_dependencies'
    SOURCE_PATH = 'src_path'
    TARGET_PATH = 'target_path'


class InnerConfigItem(str):
    pass


class InnerConfigKey(object):

    keyword_symbol = "$_"

    @classmethod
    def is_keyword(cls, s):
        return s.startswith(cls.keyword_symbol)

    @classmethod
    def to_keyword(cls, key):
        return "{}{}".format(cls.keyword_symbol, key)

    @classmethod
    def keyword_to_str(cls, _keyword):
        return str(_keyword.replace(cls.keyword_symbol, '', 1))


class ComponentInnerConfig(dict):

    COMPONENT_GLOBAL_ATTRS = InnerConfigKey.to_keyword('component_global_attrs')

    def __init__(self, component_name, config):
        super(ComponentInnerConfig, self).__init__()
        self.component_name = component_name
        c_config = {}
        for server in config:
            i_config = {}
            s_config = config[server]
            for key in s_config:
                i_config[InnerConfigItem(key)] = s_config[key]
            c_config[server] = i_config
        self.update(c_config)

    def __iter__(self):
        keys = self.keys()
        servers = []
        for key in keys:
            if key != self.COMPONENT_GLOBAL_ATTRS:
                servers.append(key)
        return iter(servers)

    def update_server_config(self, server, key, value):
        self._update_config(server, key, value)

    def update_attr(self, key, value):
        self._update_config(self.COMPONENT_GLOBAL_ATTRS, key, value)

    def del_server_config(self, server, key):
        self._del_config(server, key)

    def del_attr(self, key):
        self._del_config(self.COMPONENT_GLOBAL_ATTRS, key)

    def get_attr(self, key):
        return self._get_config(self.COMPONENT_GLOBAL_ATTRS, key)

    def _update_config(self, item, key, value):
        if not self.__contains__(item):
            self[item] = {}
        if not InnerConfigKey.is_keyword(key):
            key = InnerConfigKey.to_keyword(key)
        self[item][key] = value

    def _del_config(self, item, key):
        if not self.__contains__(item):
            return
        if not InnerConfigKey.is_keyword(key):
            key = InnerConfigKey.to_keyword(key)
        if key in self[item]:
            del self[item][key]

    def _get_config(self, item, key):
        if not self.__contains__(item):
            return
        if not InnerConfigKey.is_keyword(key):
            key = InnerConfigKey.to_keyword(key)
        return self[item].get(key)


class InnerConfigKeywords(object):

    DEPLOY_INSTALL_MODE = 'deploy_install_mode'
    DEPLOY_BASE_DIR = 'deploy_base_dir'


class InnerConfig(object):

    def __init__(self, path, yaml_loader):
        self.path = path
        self.yaml_loader = yaml_loader
        self.config = {}
        self.load_error = None
        self._load()

    def _load(self):
        self.config = {}
        self.load_error = None
        if not os.path.isfile(self.path):
            return
        try:
            with FileUtil.open(self.path, 'rb') as f:
                config = self.yaml_loader.load(f)
                if config is None:
                    config = {}
                for component_name in config:
                    if InnerConfigKey.is_keyword(component_name):
                        self.config[InnerConfigItem(component_name)] = config[component_name]
                    else:
                        self.config[component_name] = ComponentInnerConfig(component_name, config[component_name])
        except Exception as e:
            # Most callers historically treated a missing inner config as an
            # empty one.  Keep that behaviour for a missing file, but retain a
            # parse/read error so address identity handling can fail closed.
            self.load_error = e

    def _dump(self):
        temp_path = None
        try:
            parent_dir = os.path.dirname(self.path) or '.'
            fd, temp_path = tempfile.mkstemp(prefix='.%s.' % os.path.basename(self.path), suffix='.tmp', dir=parent_dir)
            with os.fdopen(fd, 'w') as f:
                self.yaml_loader.dump(self.config, f)
                f.flush()
                os.fsync(f.fileno())
            os.rename(temp_path, self.path)
            temp_path = None
            self.load_error = None
            return True
        except:
            pass
        finally:
            if temp_path and os.path.exists(temp_path):
                try:
                    os.remove(temp_path)
                except OSError:
                    pass
        return False

    def dump(self):
        return self._dump()

    def get_component_config(self, component_name):
        return self.config.get(component_name, {})

    def get_server_config(self, component_name, server):
        return self.get_component_config(component_name).get(server, {})

    def get_global_config(self, key, default=None):
        key = InnerConfigKey.to_keyword(key)
        return self.config.get(key, default)

    def update_global_config(self, key, value):
        self.config[InnerConfigKey.to_keyword(key)] = value

    def update_component_config(self, component_name, config):
        self.config[component_name] = {}
        for server in config:
            c_config = {}
            data = config[server]
            for key in data:
                if not isinstance(key, InnerConfigItem):
                    key = InnerConfigItem(key)
                c_config[key] = data[key]
            self.config[component_name][server] = c_config
        if ComponentInnerConfig.COMPONENT_GLOBAL_ATTRS in config:
            self.config[component_name][ComponentInnerConfig.COMPONENT_GLOBAL_ATTRS] = config[ComponentInnerConfig.COMPONENT_GLOBAL_ATTRS]


class ConfigParser(object):

    STYLE = ''
    INNER_CONFIG_MAP = {}
    PREFIX = '$_'
    META_KEYS = ['version', 'tag', 'release', 'package_hash']

    @classmethod
    def _is_inner_item(cls, key):
        return isinstance(key, InnerConfigItem) and key.startswith(cls.PREFIX)

    @classmethod
    def extract_inner_config(cls, cluster_config, config):
        return {}

    @staticmethod
    def _get_server(server_data):
        if isinstance(server_data, dict):
            ip = ConfigUtil.get_value_from_dict(server_data, 'ip', transform_func=str)
            name = ConfigUtil.get_value_from_dict(server_data, 'name', transform_func=str)
        else:
            ip = server_data
            name = None
        if not re.match(r'^((25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(25[0-5]|2[0-4]\d|[01]?\d{1,2})$', ip) \
                and not re.match(r'^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$', ip):
            raise Exception('Invalid ip address {}'.format(ip))
        return ServerConfigFlyweightFactory.get_instance(ip, name)

    @classmethod
    def _get_servers(cls, servers_data):
        servers = []
        for server_data in servers_data:
            servers.append(cls._get_server(server_data))
        return servers

    @classmethod
    def _to_cluster_config(cls, component_name, config, added_servers=None):
        raise NotImplementedError

    @classmethod
    def merge_config(cls, component_name, config, new_config):
        raise NotImplementedError

    @classmethod
    def to_cluster_config(cls, component_name, config, added_servers=None):
        cluster_config = cls._to_cluster_config(component_name, config, added_servers)
        cluster_config.set_include_file(config.get('include', ''))
        cluster_config.parser = cls
        return cluster_config

    @classmethod
    def _from_cluster_config(cls, conf, cluster_config):
        raise NotImplementedError

    @classmethod
    def from_cluster_config(cls, cluster_config):
        if not cls.STYLE:
            raise NotImplementedError('undefined Style ConfigParser')

        conf = CommentedMap()
        conf['style'] = cls.STYLE
        if cluster_config.origin_package_hash:
            conf['package_hash'] = cluster_config.origin_package_hash
        if cluster_config.origin_version:
            conf['version'] = cluster_config.origin_version
        if cluster_config.origin_tag:
            conf['tag'] = cluster_config.origin_tag
        if cluster_config.origin_release:
            conf['release'] = cluster_config.origin_release
        if cluster_config.depends:
            conf['depends'] = list(cluster_config.depends)
        conf = cls._from_cluster_config(conf, cluster_config)
        inner_config = cls.extract_inner_config(cluster_config, conf)
        return {
            'inner_config': inner_config,
            'config': conf
        }

    @classmethod
    def get_server_src_conf(cls, cluster_config, component_config, server):
        if server.name not in component_config:
            component_config[server.name] = {}
        return component_config[server.name]

    @classmethod
    def get_global_src_conf(cls, cluster_config, component_config):
        if 'global' not in component_config:
            component_config['global'] = {}
        return component_config['global']


class DefaultConfigParser(ConfigParser):

    STYLE = 'default'

    @classmethod
    def _to_cluster_config(cls, component_name, conf, added_servers=None):
        servers = cls._get_servers(conf.get('servers', []))
        cluster_config = ClusterConfig(
            servers,
            component_name,
            ConfigUtil.get_value_from_dict(conf, 'version', None, str),
            ConfigUtil.get_value_from_dict(conf, 'tag', None, str),
            ConfigUtil.get_value_from_dict(conf, 'release', None, str),
            ConfigUtil.get_value_from_dict(conf, 'package_hash', None, str),
            ConfigUtil.get_value_from_dict(conf, 'type', 'rpm', str),
            ConfigUtil.get_value_from_dict(conf, 'image_name', 'None', str)
        )
        if added_servers:
            cluster_config.added_servers = added_servers


        receivers = set()
        if 'global' in conf:
            cluster_config.set_global_conf(conf['global'])
            if conf['global'].get('receivers'):
                receivers_data = conf['global'].get('receivers')
                if isinstance(receivers_data, list):
                    for item in receivers_data:
                        if not isinstance(item, str):
                            raise ReceiversConfigError(
                                f"Expected all elements in 'receivers' list to be strings, but found {type(item).__name__}: {item}"
                            )
                    receivers = set(receivers_data)
                else:
                    raise ReceiversConfigError(
                        f"Expected 'receivers' in global config to be a list, but got {type(receivers_data).__name__}. "
                    )
        if RsyncConfig.RSYNC in conf:
            cluster_config.set_rsync_list(conf[RsyncConfig.RSYNC])

        if ENV in conf:
            cluster_config.set_environments(conf[ENV])

        for server in servers:
            if server.name in conf:
                cluster_config.add_server_conf(server, conf[server.name])
                if 'receivers' in conf[server.name]:
                    for receiver in conf[server.name].get('receivers'):
                        receivers.add(receiver)
        
        for receiver in receivers:
            if conf.get(receiver):
                cluster_config.update_receivers_conf(receiver, conf[receiver])
        return cluster_config

    @classmethod
    def merge_config(cls, component_name, config, new_config):
        unmergeable_keys = cls.META_KEYS + ['global', RsyncConfig.RSYNC, ENV]
        for key in unmergeable_keys:
            assert key not in new_config, Exception('{} is not allowed to be set in additional conf'.format(key))
        servers = cls._get_servers(config.get('servers', []))
        merge_servers = cls._get_servers(new_config.get('servers', []))
        for server in merge_servers:
            assert server not in servers, Exception('{} is already in cluster'.format(server))
        config['servers'] = config.get('servers', []) + new_config.get('servers', [])
        merge_server_names = [server.name for server in merge_servers]
        for key in merge_server_names:
            if key in new_config:
                config[key] = new_config[key]
        return cls.to_cluster_config(component_name, config, merge_servers)

    @classmethod
    def extract_inner_config(cls, cluster_config, config):
        inner_config = cluster_config.get_inner_config()
        for server in cluster_config.servers:
            if server.name not in inner_config:
                inner_config[server.name] = {}

        global_config = config.get('global', {})
        keys = list(global_config.keys())
        for key in keys:
            if cls._is_inner_item(key):
                for server in cluster_config.servers:
                    inner_config[server.name][key] = global_config[key]
                del global_config[key]

        for server in cluster_config.servers:
            if server.name not in config:
                continue
            server_config = config[server.name]
            keys = list(server_config.keys())
            for key in keys:
                if cls._is_inner_item(key):
                    inner_config[server.name][key] = server_config[key]
                    del server_config[key]
        return inner_config

    @classmethod
    def _from_cluster_config(cls, conf, cluster_config):
        conf['servers'] = []
        for server in cluster_config.servers:
            if server.name == server.ip:
                conf['servers'].append(server.name)
            else:
                conf['servers'].append({'name': server.name, 'ip': server.ip})

        if cluster_config.get_original_global_conf():
            conf['global'] = cluster_config.get_original_global_conf()
        for server in cluster_config.servers:
            server_config = cluster_config.get_original_server_conf(server)
            if server_config:
                conf[server.name] = server_config

        if cluster_config.get_receivers_conf():
            for key, value in cluster_config.get_receivers_conf().items():
                conf[key] = value
        return conf


class ClusterConfig(object):

    def __init__(self, servers, name, version, tag, release, package_hash, comp_type, image_name, parser=None):
        if comp_type == 'docker':
            version = Version('1.0.0')
        if comp_type == 'dockers':
            version = Version(tag)
            if name == const.COMP_PRAG:
                image_name = const.POWERRAG_IMAGE
        self._version = version
        self.origin_version = version
        self.tag = tag
        self.comp_type = comp_type
        self.origin_tag = tag
        self._release = release
        self.origin_release = release
        self.name = name
        self.image_name = image_name
        self.origin_package_hash = package_hash
        self._package_hash = package_hash
        self._temp_conf = {}
        self._all_default_conf = {}
        self._default_conf = {}
        self._global_conf = None
        self._server_conf = {}
        self._cache_server = {}
        self._original_global_conf = {}
        self._rsync_list = None
        self._include_config = None
        self._origin_rsync_list = {}
        self._include_file = None
        self._origin_include_file = None
        self._origin_include_config = None
        self._unprocessed_global_conf = None
        self._unprocessed_server_conf = {}
        self._environments = None
        self._origin_environments = {}
        self._inner_config = {}
        self._base_dir = ''
        servers = list(servers)
        self.servers = servers
        self._original_servers = servers # 保证顺序
        for server in servers:
            self._server_conf[server] = {}
            self._cache_server[server] = None
        self._deploy_config = None
        self._depends = {}
        self._be_depends = {}
        self.parser = parser
        self._has_package_pattern = None
        self._object_hash = None
        self.added_servers = []
        self._receivers_conf = {}

    if sys.version_info.major == 2:
        def __hash__(self):
            if self._object_hash is None:
                m_sum = hashlib.md5()
                m_sum.update(str(self.package_hash).encode('utf-8'))
                m_sum.update(str(self.get_global_conf()).encode('utf-8'))
                for server in self.servers:
                    m_sum.update(str(self.get_server_conf(server)).encode('utf-8'))
                m_sum.update(str(self.depends).encode('utf-8'))
                self._object_hash = int(''.join(['%03d' % ord(v) for v in m_sum.digest()]))
            return self._object_hash
    else:
        def __hash__(self):
            if self._object_hash is None:
                m_sum = hashlib.md5()
                m_sum.update(str(self.package_hash).encode('utf-8'))
                m_sum.update(str(self.get_global_conf()).encode('utf-8'))
                for server in self.servers:
                    m_sum.update(str(self.get_server_conf(server)).encode('utf-8'))
                m_sum.update(str(self.depends).encode('utf-8'))
                self._object_hash = (int(''.join(['%03d' % v for v in m_sum.digest()])))
            return self._object_hash

    def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return False
        # todo 检查 rsync include等
        if self.servers != other.servers:
            return False
        if self.get_global_conf() != other.get_global_conf():
            return False
        for server in self.servers:
            if self.get_server_conf(server) != other.get_server_conf(server):
                return False
        for key in self.get_receivers_conf():
            if self.get_receivers_conf_detail(key) != other.get_receivers_conf_detail(key):
                return False
        return True

    def __deepcopy__(self, memo):
        cluster_config = self.__class__(deepcopy(self.servers), self.name, self.version, self.tag, self.release, self.package_hash, self.image_name, self.parser)
        copy_attrs = ['origin_tag', 'origin_version', 'origin_package_hash', 'parser', 'added_servers']
        deepcopy_attrs = ['_temp_conf', '_all_default_conf', '_default_conf', '_global_conf', '_server_conf', '_cache_server', '_original_global_conf', '_depends', '_original_servers', '_inner_config']
        for attr in copy_attrs:
            setattr(cluster_config, attr, getattr(self, attr))
        for attr in deepcopy_attrs:
            setattr(cluster_config, attr, deepcopy(getattr(self, attr)))
        return cluster_config

    def set_deploy_config(self, _deploy_config):
        if self._deploy_config is None:
            self._deploy_config = _deploy_config
            self.set_base_dir(self._deploy_config.get_base_dir())
            return True
        return False

    def set_base_dir(self, base_dir):
        if self._base_dir != base_dir:
            self._base_dir = base_dir
            self._rsync_list = None
            self._include_config = None
            self._global_conf = None

    @property
    def docker_install(self):
        return self.comp_type == 'docker'

    @property
    def docker_compose_install(self):
        return self.comp_type == 'dockers'

    @property
    def deploy_name(self):
        return self._deploy_config.name

    @property
    def original_servers(self):
        return self._original_servers

    @property
    def depends(self):
        return self._depends.keys()
    
    @property
    def be_depends(self):
        return self._be_depends.keys()

    def _clear_cache_server(self):
        for server in self._cache_server:
            self._cache_server[server] = None
            if server in self._unprocessed_server_conf:
                del self._unprocessed_server_conf[server]

    def get_inner_config(self):
        return self._inner_config

    def _save_component_inner_config(self, previous, save):
        if not save or self._deploy_config.dump_inner_config():
            return True
        # Keep the shared ComponentInnerConfig object alive because
        # DeployConfig.inner_config references the same instance.
        self._inner_config.clear()
        self._inner_config.update(previous)
        return False
    
    def update_component_attr(self, key, value, save=True):
        previous = deepcopy(self._inner_config)
        self._inner_config.update_attr(key, value)
        return self._save_component_inner_config(previous, save)

    def update_component_attrs(self, attrs, save=True):
        previous = deepcopy(self._inner_config)
        for key, value in attrs.items():
            self._inner_config.update_attr(key, value)
        return self._save_component_inner_config(previous, save)
    
    def del_component_attr(self, key, save=True):
        previous = deepcopy(self._inner_config)
        self._inner_config.del_attr(key)
        return self._save_component_inner_config(previous, save)
    
    def get_component_attr(self, key):
        return self._inner_config.get_attr(key)
    
    def is_cp_install_mode(self):
        return self._deploy_config.is_cp_install_mode()

    def is_ln_install_mode(self):
        return self._deploy_config.is_ln_install_mode()

    def apply_inner_config(self, config):
        if not isinstance(config, ComponentInnerConfig):
            config = ComponentInnerConfig(self.name, {} if config is None else config)
        self._inner_config = config
        self._clear_cache_server()

    def add_depend(self, name, cluster_conf):
        if self.name == name:
            raise Exception('Can not set %s as %s\'s dependency' % (name, name))
        if self.name in cluster_conf.depends:
            raise Exception('Circular Dependency: %s and %s' % (self.name, name))
        self._depends[name] = cluster_conf
        cluster_conf.add_be_depend(self.name, self)

    def add_be_depend(self, name, cluster_conf):
        if self.name == name:
            raise Exception('Can not set %s as %s\'s dependency' % (name, name))
        if self.name not in cluster_conf.depends:
            raise Exception('%s is not %s\'s dependency' % (self.name, name))
        if self.name in cluster_conf.be_depends:
            raise Exception('Circular Dependency: %s and %s' % (self.name, name))
        self._be_depends[name] = cluster_conf

    def add_depend_component(self, depend_component_name):
        return self._deploy_config.add_depend_for_component(self.name, depend_component_name, save=False)

    def del_depend(self, name, component_name):
        if component_name in self._depends:
            del self._depends[component_name]

    def get_depend_servers(self, name):
        if name not in self._depends:
            return []
        cluster_config = self._depends[name]
        return deepcopy(cluster_config.original_servers)
    
    def get_be_depend_servers(self, name):
        if name not in self._be_depends:
            return []
        cluster_config = self._be_depends[name]
        return deepcopy(cluster_config.original_servers)
        
    def get_depend_added_servers(self, name):
        if name not in self._depends:
            return None
        cluster_config = self._depends[name]
        return deepcopy(cluster_config.added_servers)
    
    def get_deploy_added_components(self):
        return self._deploy_config.added_components
    
    def get_deploy_changed_components(self):
        return self._deploy_config.changed_components

    def get_deploy_removed_components(self):
        return self._deploy_config.removed_components
        
    def get_depend_config(self, name, server=None, with_default=True):
        if name not in self._depends:
            return None
        cluster_config = self._depends[name]
        if with_default:
            config = cluster_config.get_server_conf_with_default(server) if server else cluster_config.get_global_conf_with_default()
        else:
            config = cluster_config.get_server_conf(server) if server else cluster_config.get_global_conf()
        return deepcopy(config)

    def get_depend_cluster_config(self, name):
        return self._depends.get(name)

    def get_be_depend_config(self, name, server=None, with_default=True):
        if name not in self._be_depends:
            return None
        cluster_config = self._be_depends[name]
        if with_default:
            config = cluster_config.get_server_conf_with_default(server) if server else cluster_config.get_global_conf_with_default()
        else:
            config = cluster_config.get_server_conf(server) if server else cluster_config.get_global_conf()
        return deepcopy(config)

    def update_server_conf(self, server, key, value, save=True):
        if self._deploy_config is None:
            return False
        if server not in self._server_conf:
            return False
        if self._temp_conf and key in self._temp_conf:
            value = self._temp_conf[key].param_type(value).value
        if not self._deploy_config.update_component_server_conf(self.name, server, key, value, save):
            return False
        self._server_conf[server][key] = value
        if self._cache_server[server] is not None:
            self._cache_server[server][key] = value
        return True

    def update_global_conf(self, key, value, save=True):
        if self._deploy_config is None:
            return False
        if self._temp_conf and key in self._temp_conf:
            value = self._temp_conf[key].param_type(value).value
        if not self._deploy_config.update_component_global_conf(self.name, key, value, save):
            return False
        self._update_global_conf(key, value)
        return True

    def _update_global_conf(self, key, value):
        self._original_global_conf[key] = value
        self._global_conf = None
        self._unprocessed_global_conf = None
        self._clear_cache_server()

    def update_rsync_list(self, rsync_list, save=True):
        if self._deploy_config is None:
            return False
        if not self._deploy_config.update_component_rsync_list(self.name, rsync_list, save):
            return False
        self._rsync_list = rsync_list
        return True

    def update_environments(self, environments, save=True):
        if self._deploy_config is None:
            return False
        if not self._deploy_config.update_component_environments(self.name, environments, save):
            return False
        self._origin_environments = environments
        self._environments = None
        return True

    def get_unconfigured_require_item(self, server, skip_keys=[]):
        items = []
        config = self._get_unprocessed_server_conf(server)
        if config is not None:
            for key in self._temp_conf:
                if key in skip_keys:
                    continue
                if not self._temp_conf[key].require:
                    continue
                if key in config:
                    continue
                items.append(key)
        return items

    def get_server_conf_with_default(self, server):
        if server not in self._server_conf:
            return None
        config = deepcopy(self._all_default_conf)
        server_config = self.get_server_conf(server)
        if server_config:
            config.update(server_config)
        return config

    def get_need_redeploy_items(self, server):
        if server not in self._server_conf:
            return None
        items = {}
        config = self.get_server_conf(server)
        for key in config:
            if key in self._temp_conf and self._temp_conf[key].need_redeploy:
                items[key] = config[key]
        return items

    def get_read_only_items(self, server):
        if server not in self._server_conf:
            return None
        items = {}
        config = self.get_server_conf(server)
        for key in config:
            if key in self._temp_conf and self._temp_conf[key].read_only:
                items[key] = config[key]
        return items

    def get_need_restart_items(self, server):
        if server not in self._server_conf:
            return None
        items = {}
        config = self.get_server_conf(server)
        for key in config:
            if key in self._temp_conf and self._temp_conf[key].need_restart:
                items[key] = config[key]
        return items
        
    def update_temp_conf(self, temp_conf):
        self._default_conf = {}
        self._all_default_conf = {}
        self._temp_conf = temp_conf
        for key in self._temp_conf:
            if self._temp_conf[key].require and self._temp_conf[key].default is not None:
                self._default_conf[key] = self._temp_conf[key].default
            if self._temp_conf[key].default is not None:
                self._all_default_conf[key] = self._temp_conf[key].default
        self._global_conf = None
        self._unprocessed_global_conf = None
        self._clear_cache_server()

    def _apply_temp_conf(self, conf):
        if self._temp_conf:
            for key in conf:
                if key in self._temp_conf:
                    conf[key] = self._temp_conf[key].param_type(conf[key]).value
        return conf

    def get_temp_conf_item(self, key):
        if self._temp_conf:
            return self._temp_conf.get(key)
        else:
            return None

    def check_param(self):
        errors = []
        if self._temp_conf:
            _, g_errs = self.global_check_param()
            errors += g_errs
            for server in self._server_conf:
                s_errs, _ = self._check_param(self._server_conf[server])
                errors += s_errs
        return not errors, set(errors)

    def global_check_param(self):
        errors = []
        if self._temp_conf:
            errors, _ = self._check_param(self._get_unprocessed_global_conf())
        return not errors, errors

    def servers_check_param(self):
        check_res = {}
        if self._temp_conf:
            global_config = self._get_unprocessed_global_conf()
            for server in self._server_conf:
                config = deepcopy(self._server_conf[server])
                config.update(global_config)
                errors, items = self._check_param(config)
                check_res[server] = {'errors': errors, 'items': items}
        return check_res

    def _check_param(self, config):
        errors = []
        items = []
        for key in config:
            item = self._temp_conf.get(key)
            if item:
                try:
                    item.check_value(config[key])
                except Exception as e:
                    errors.append(str(e))
                    items.append(item)
        return errors, items

    def set_global_conf(self, conf):
        if not isinstance(conf, dict):
            raise Exception('%s global config is not a dictionary. Please check the syntax of your configuration file.\n See https://github.com/oceanbase/obdeploy/blob/master/docs/zh-CN/4.configuration-file-description.md' % self.name)
        self._original_global_conf = deepcopy(conf)
        self._global_conf = None
        self._clear_cache_server()

    def set_rsync_list(self, configs):
        self._origin_rsync_list = configs

    def update_receivers_conf(self, key, conf):
        self._receivers_conf[key] = conf

    def set_include_file(self, path):
        if path != self._origin_include_file:
            self._origin_include_file = path
            self._include_file = None
            self._include_config = None

    def set_environments(self, config):
        self._origin_environments = config
        self._environments = None

    def add_server_conf(self, server, conf):
        if server not in self.servers:
            self.servers.append(server)
        if server not in self._original_servers:
            self._original_servers.append(server)
        self._server_conf[server] = conf
        self._cache_server[server] = None

    def _get_unprocessed_global_conf(self):
        if self._unprocessed_global_conf is None:
            self._unprocessed_global_conf = deepcopy(self._default_conf)
            self._unprocessed_global_conf.update(self._get_include_config('config', {}))
            if self._original_global_conf:
                self._unprocessed_global_conf.update(self._original_global_conf)
        return self._unprocessed_global_conf

    def get_global_conf(self):
        if self._global_conf is None:
            self._global_conf = self._apply_temp_conf(self._get_unprocessed_global_conf())
        return self._global_conf
    
    def get_receivers_conf(self):
        return self._receivers_conf
    
    def get_receivers_conf_detail(self, key):
        return self._receivers_conf.get(key)

    def get_global_conf_with_default(self):
        config = deepcopy(self._all_default_conf)
        config.update(self.get_global_conf())
        return config

    def _add_base_dir(self, path):
        if not os.path.isabs(path):
            if self._base_dir:
                path = os.path.join(self._base_dir, path)
            else:
                raise Exception("`{}` need to use absolute paths. If you want to use relative paths, please enable developer mode "
                "and set environment variables {}".format(RsyncConfig.RSYNC, ENV_BASE_DIR))
        return path

    @property
    def has_package_pattern(self):
        if self._has_package_pattern is None:
            patterns = (self.origin_package_hash, self.origin_version, self.origin_release, self.origin_tag)
            self._has_package_pattern = any([x is not None for x in patterns])
        return self._has_package_pattern

    @property
    def version(self):
        if self._version is None:
            self._version = self.config_version
        return self._version

    @version.setter
    def version(self, value):
        self._version = value

    @property
    def config_version(self):
        if not self.has_package_pattern:
            return self._get_include_config('version', None)
        else:
            return self.origin_version

    @property
    def release(self):
        if self._release is None:
            self._release = self.config_release
        return self._release

    @release.setter
    def release(self, value):
        self._release = value

    @property
    def config_release(self):
        if not self.has_package_pattern:
            return self._get_include_config('release', None)
        else:
            return self.origin_release

    @property
    def package_hash(self):
        if self._package_hash is None:
            self._package_hash = self.config_package_hash
        return self._package_hash

    @package_hash.setter
    def package_hash(self, value):
        self._package_hash = value

    @property
    def config_package_hash(self):
        if not self.has_package_pattern:
            return self._get_include_config('package_hash', None)
        else:
            return self.origin_package_hash
    
    def _get_include_config(self, key=None, default=None, not_found_act="ignore"):
        if self._include_config is None:
            if self._origin_include_file:
                if os.path.isabs(self._origin_include_file):
                    include_file = self._origin_include_file
                else:
                    include_file = os.path.join(self._base_dir, self._origin_include_file)
                if include_file != self._include_file:
                    self._include_file = include_file
                    self._origin_include_config = self._deploy_config.load_include_file(self._include_file)
            if self._origin_include_config is None:
                self._origin_include_config = {}
            self._include_config = self._origin_include_config
        value = self._include_config.get(key, default) if key else self._include_config
        return deepcopy(value)

    def get_rsync_list(self):
        if self._rsync_list is None:
            self._rsync_list = self._get_include_config(RsyncConfig.RSYNC, [])
            self._rsync_list += self._origin_rsync_list
            for item in self._rsync_list:
                item[RsyncConfig.SOURCE_PATH] = self._add_base_dir(item[RsyncConfig.SOURCE_PATH])
        return self._rsync_list

    def get_environments(self):
        if self._environments is None:
            self._environments = self._get_include_config(ENV, OrderedDict())
            self._environments.update(self._origin_environments)
        return self._environments

    def _get_unprocessed_server_conf(self, server):
        if server not in self._unprocessed_server_conf:
            conf = deepcopy(self._inner_config.get(server.name, {}))
            conf.update(self._get_unprocessed_global_conf())
            conf.update(self._server_conf[server])
            self._unprocessed_server_conf[server] = conf
        return self._unprocessed_server_conf[server]

    def get_server_conf(self, server):
        if server not in self._server_conf:
            return None
        if self._cache_server[server] is None:
            self._cache_server[server] = self._apply_temp_conf(self._get_unprocessed_server_conf(server))
        return self._cache_server[server]

    def get_original_global_conf(self, format_conf=False):
        conf = deepcopy(self._original_global_conf)
        format_conf and self._apply_temp_conf(conf)
        return conf

    def get_original_server_conf(self, server, format_conf=False):
        conf = deepcopy(self._server_conf.get(server))
        format_conf and self._apply_temp_conf(conf)
        return conf

    def get_original_server_conf_with_global(self, server, format_conf=False):
        config = deepcopy(self.get_original_global_conf())
        config.update(self._server_conf.get(server, {}))
        format_conf and self._apply_temp_conf(config)
        return config

    def get_explicit_server_conf(self, server, format_conf=False):
        """Return include/global/server values without parameter defaults."""
        config = self._get_include_config('config', {})
        config.update(self.get_original_global_conf())
        config.update(self._server_conf.get(server, {}))
        format_conf and self._apply_temp_conf(config)
        return config


class DeployStatus(Enum):

    STATUS_CONFIGUREING = 'configuring'
    STATUS_CONFIGURED = 'configured'
    STATUS_DEPLOYING = 'delopying'
    STATUS_DEPLOYED = 'deployed'
    STATUS_RUNNING = 'running'
    STATUS_STOPING = 'stoping'
    STATUS_STOPPED = 'stopped'
    STATUS_DESTROYING = 'destroying'
    STATUS_DESTROYED = 'destroyed'
    STATUS_UPRADEING = 'upgrading'


class ObserverIdentityError(Exception):
    pass


class ObserverIdentity(object):
    """Resolve standalone observer identity without changing management IPs."""

    VALID_STATES = (const.OBSERVER_IDENTITY_PLANNED, const.OBSERVER_IDENTITY_VERIFIED)
    VALID_SOURCES = (const.OBSERVER_IDENTITY_FRESH_BOOTSTRAP, const.OBSERVER_IDENTITY_LEGACY_MANUAL)

    @classmethod
    def _check_inner_config(cls, cluster_config):
        deploy_config = getattr(cluster_config, '_deploy_config', None)
        inner_config = getattr(deploy_config, 'inner_config', None)
        error = getattr(inner_config, 'load_error', None)
        if cluster_config.name == const.COMP_OB_STANDALONE and error:
            raise ObserverIdentityError('failed to load OBD inner config: %s' % error)

    @classmethod
    def _marker(cls, cluster_config):
        cls._check_inner_config(cluster_config)
        identity_ip = cluster_config.get_component_attr(const.OBSERVER_IDENTITY_IP)
        state = cluster_config.get_component_attr(const.OBSERVER_IDENTITY_STATE)
        source = cluster_config.get_component_attr(const.OBSERVER_IDENTITY_SOURCE)
        values = (identity_ip, state, source)
        if not any(values):
            return None
        if not all(values):
            raise ObserverIdentityError('standalone observer identity metadata is incomplete')
        if identity_ip != const.OBSERVER_LOOPBACK_IP:
            raise ObserverIdentityError('unsupported standalone observer identity ip: %s' % identity_ip)
        if state not in cls.VALID_STATES:
            raise ObserverIdentityError('unsupported standalone observer identity state: %s' % state)
        if source not in cls.VALID_SOURCES:
            raise ObserverIdentityError('unsupported standalone observer identity source: %s' % source)
        return {'ip': identity_ip, 'state': state, 'source': source}

    @classmethod
    def marker(cls, cluster_config):
        if cluster_config.name != const.COMP_OB_STANDALONE:
            return None
        return cls._marker(cluster_config)

    @classmethod
    def _server(cls, cluster_config, server=None):
        if server is not None:
            return server
        if len(cluster_config.servers) != 1:
            raise ObserverIdentityError('standalone loopback identity requires exactly one server')
        return cluster_config.servers[0]

    @classmethod
    def management_ip(cls, cluster_config, server=None):
        return cls._server(cluster_config, server).ip

    @classmethod
    def identity_ip(cls, cluster_config, server=None):
        marker = cls.marker(cluster_config)
        if marker:
            return marker['ip']
        server = cls._server(cluster_config, server)
        # Explicit 127 is the pre-marker legacy contract.  Other local_ip
        # values never replace the historical management-IP identity.
        if cls.is_explicit_legacy_loopback(cluster_config, server):
            return const.OBSERVER_LOOPBACK_IP
        return server.ip

    @classmethod
    def is_explicit_legacy_loopback(cls, cluster_config, server=None):
        if cluster_config.name != const.COMP_OB_STANDALONE:
            return False
        server = cls._server(cluster_config, server)
        return cluster_config.get_server_conf(server).get('local_ip') == const.OBSERVER_LOOPBACK_IP

    @classmethod
    def _has_initialization_evidence(cls, plugin_context, cluster_config, server, server_config):
        clients = getattr(plugin_context, 'clients', {}) or {}
        client = clients.get(server)
        if not client:
            raise ObserverIdentityError('missing management client while inspecting observer initialization state on %s' % server.ip)
        home_path = server_config.get('home_path')
        if home_path:
            result = client.execute_command('test -e %s/etc/observer.config.bin' % home_path)
            if result.code == 0:
                return True
            if result.code != 1:
                raise ObserverIdentityError('failed to inspect observer initialization state on %s: %s' % (
                    server.ip, result.stderr))
        data_dir = server_config.get('data_dir') or ('%s/store' % home_path if home_path else None)
        clog_sub_dir = plugin_context.get_variable('clog_sub_dir', 'clog')
        if data_dir:
            result = client.execute_command('test -d %s/%s' % (data_dir, clog_sub_dir))
            if result.code == 0:
                result = client.execute_command('ls -A %s/%s/' % (data_dir, clog_sub_dir))
                if result.code != 0:
                    raise ObserverIdentityError('failed to inspect observer initialization state on %s: %s' % (
                        server.ip, result.stderr))
                return bool(result.stdout.strip())
            if result.code != 1:
                raise ObserverIdentityError('failed to inspect observer initialization state on %s: %s' % (
                    server.ip, result.stderr))
        return False

    @classmethod
    def is_loopback(cls, cluster_config):
        marker = cls.marker(cluster_config)
        return bool(marker and marker['ip'] == const.OBSERVER_LOOPBACK_IP) or \
            (not marker and cls.is_explicit_legacy_loopback(cluster_config))

    @classmethod
    def prepare(cls, plugin_context, cluster_config):
        """Persist intent before observer's first start and return the marker."""
        if cluster_config.name != const.COMP_OB_STANDALONE:
            return None
        marker = cls._marker(cluster_config)
        if marker:
            server = cls._server(cluster_config)
            server_config = cluster_config.get_server_conf(server)
            explicit_local_ip = server_config.get('local_ip')
            if server_config.get('devname'):
                raise ObserverIdentityError('devname cannot be used with standalone loopback identity')
            if explicit_local_ip and explicit_local_ip != marker['ip']:
                raise ObserverIdentityError('local_ip conflicts with persisted standalone observer identity %s' % marker['ip'])
            return marker

        server = cls._server(cluster_config)
        server_config = cluster_config.get_server_conf(server)
        explicit_local_ip = server_config.get('local_ip')
        legacy_loopback = explicit_local_ip == const.OBSERVER_LOOPBACK_IP
        status = getattr(plugin_context, 'deploy_status', None)
        is_first_start = getattr(status, 'value', status) == DeployStatus.STATUS_DEPLOYED.value
        supports_loopback = cluster_config.version is not None and \
            Version(cluster_config.version) >= Version(const.OB_STANDALONE_LOOPBACK_MIN_VERSION)

        if not legacy_loopback and not (is_first_start and supports_loopback):
            return None
        if not legacy_loopback and cls._has_initialization_evidence(
                plugin_context, cluster_config, server, server_config):
            # OBD persists planned before launching all new loopback
            # deployments.  Existing observer state without that marker must
            # therefore retain historical real-IP semantics.
            return None
        if server_config.get('devname'):
            raise ObserverIdentityError('devname cannot be used with standalone loopback identity')
        if explicit_local_ip and explicit_local_ip != const.OBSERVER_LOOPBACK_IP:
            raise ObserverIdentityError('local_ip must be omitted or set to %s for standalone %s or later' % (
                const.OBSERVER_LOOPBACK_IP, const.OB_STANDALONE_LOOPBACK_MIN_VERSION))

        source = const.OBSERVER_IDENTITY_LEGACY_MANUAL if legacy_loopback else const.OBSERVER_IDENTITY_FRESH_BOOTSTRAP
        state = const.OBSERVER_IDENTITY_PLANNED
        attrs = {
            const.OBSERVER_IDENTITY_IP: const.OBSERVER_LOOPBACK_IP,
            const.OBSERVER_IDENTITY_STATE: state,
            const.OBSERVER_IDENTITY_SOURCE: source,
        }
        if not cluster_config.update_component_attrs(attrs):
            raise ObserverIdentityError('failed to persist standalone observer identity before start')
        return {'ip': const.OBSERVER_LOOPBACK_IP, 'state': state, 'source': source}

    @classmethod
    def verify(cls, cluster_config, raw_servers):
        marker = cls.marker(cluster_config)
        if not marker:
            return True
        if len(raw_servers) != 1:
            raise ObserverIdentityError('standalone loopback identity expected one observer, got %s' % len(raw_servers))
        raw_ips = set(row.get('svr_ip') for row in raw_servers)
        if raw_ips != set([marker['ip']]):
            raise ObserverIdentityError('observer identity mismatch: expected %s, got %s' % (
                marker['ip'], ','.join(sorted(str(ip) for ip in raw_ips))))
        server = cls._server(cluster_config)
        server_config = cluster_config.get_server_conf(server)
        raw_server = raw_servers[0]
        expected_ports = {
            'svr_port': server_config.get('rpc_port'),
            'inner_port': server_config.get('mysql_port'),
        }
        for key, expected in expected_ports.items():
            if key in raw_server and expected is not None and int(raw_server[key]) != int(expected):
                raise ObserverIdentityError('observer identity %s mismatch: expected %s, got %s' % (
                    key, expected, raw_server[key]))
        if marker['state'] == const.OBSERVER_IDENTITY_PLANNED:
            if not cluster_config.update_component_attr(
                    const.OBSERVER_IDENTITY_STATE, const.OBSERVER_IDENTITY_VERIFIED):
                raise ObserverIdentityError('failed to persist verified standalone observer identity')
        return True

    @classmethod
    def externalize_ip(cls, cluster_config, raw_ip):
        marker = cls.marker(cluster_config)
        if marker:
            if marker['state'] == const.OBSERVER_IDENTITY_VERIFIED and raw_ip == marker['ip']:
                return cls.management_ip(cluster_config)
            return raw_ip
        # The raw row itself confirms the identity for a markerless legacy
        # deployment, so it is safe to expose the management endpoint.
        if raw_ip == const.OBSERVER_LOOPBACK_IP and cls.is_explicit_legacy_loopback(cluster_config):
            return cls.management_ip(cluster_config)
        return raw_ip

    @classmethod
    def externalize_endpoint(cls, cluster_config, endpoint):
        """Translate the IP part of an observer endpoint to its management IP."""
        if not endpoint or not cluster_config:
            return endpoint
        address, plus, extra_port = endpoint.partition('+')
        raw_ip, separator, sql_port = address.rpartition(':')
        if not separator:
            return cls.externalize_ip(cluster_config, address)
        external_ip = cls.externalize_ip(cluster_config, raw_ip)
        result = '%s:%s' % (external_ip, sql_port)
        return '%s+%s' % (result, extra_port) if plus else result

    @classmethod
    def externalize_ip_list(cls, cluster_config, ip_list):
        """Translate every endpoint in a semicolon-separated observer IP list."""
        if not ip_list or not cluster_config:
            return ip_list
        return ';'.join(cls.externalize_endpoint(cluster_config, endpoint) for endpoint in ip_list.split(';'))

    @classmethod
    def require_verified_loopback_capability(cls, cluster_configs, capability):
        """Fail closed when a sensitive operation targets an unverified loopback identity."""
        if isinstance(cluster_configs, dict):
            cluster_configs = cluster_configs.values()
        elif not isinstance(cluster_configs, (list, tuple, set)):
            cluster_configs = [cluster_configs]
        for cluster_config in cluster_configs:
            if not cluster_config or cluster_config.name != const.COMP_OB_STANDALONE:
                continue
            marker = cls.marker(cluster_config)
            if marker:
                if marker['state'] != const.OBSERVER_IDENTITY_VERIFIED:
                    raise ObserverIdentityError(
                        '%s requires a verified standalone loopback identity; current state is %s' % (
                            capability, marker['state']))
                continue
            if cls.is_explicit_legacy_loopback(cluster_config):
                raise ObserverIdentityError(
                    '%s requires verified standalone loopback identity metadata' % capability)

    @classmethod
    def require_verified_observed_loopback_capability(cls, cluster_config, cursor, capability):
        """Validate the live observer identity after a management connection is established."""
        if not cluster_config or cluster_config.name != const.COMP_OB_STANDALONE or not cursor:
            return
        rows = cursor.fetchall(
            'SELECT DISTINCT SVR_IP AS svr_ip FROM oceanbase.DBA_OB_SERVERS',
            raise_exception=False, exc_level='verbose')
        if not rows:
            raise ObserverIdentityError(
                'failed to inspect standalone observer identity before %s' % capability)
        raw_ips = set(row.get('svr_ip', row.get('SVR_IP')) for row in rows)
        marker = cls.marker(cluster_config)
        if const.OBSERVER_LOOPBACK_IP in raw_ips:
            if raw_ips != set([const.OBSERVER_LOOPBACK_IP]):
                raise ObserverIdentityError(
                    'ambiguous standalone observer identities before %s: %s' % (
                        capability, ','.join(sorted(str(ip) for ip in raw_ips))))
            if not marker or marker['state'] != const.OBSERVER_IDENTITY_VERIFIED:
                raise ObserverIdentityError(
                    '%s requires verified standalone loopback identity metadata' % capability)
        elif marker:
            raise ObserverIdentityError(
                'standalone observer identity mismatch before %s: expected %s, got %s' % (
                    capability, marker['ip'], ','.join(sorted(str(ip) for ip in raw_ips))))

    @classmethod
    def externalize_sql_endpoint(cls, cluster_config, endpoint):
        """Validate a loopback SQL endpoint against its deployment before externalizing it."""
        if not cluster_config:
            raise ObserverIdentityError('missing cluster config for standalone loopback endpoint')
        if cluster_config.name != const.COMP_OB_STANDALONE:
            return endpoint
        marker = cls.marker(cluster_config)
        if not marker:
            endpoint_address = str(endpoint).split('+', 1)[0] if endpoint is not None else ''
            if endpoint_address.rpartition(':')[0] == const.OBSERVER_LOOPBACK_IP:
                raise ObserverIdentityError(
                    'standalone loopback endpoint requires verified identity metadata')
            return cls.externalize_endpoint(cluster_config, endpoint)
        if marker['state'] != const.OBSERVER_IDENTITY_VERIFIED:
            raise ObserverIdentityError(
                'standalone loopback endpoint requires verified identity metadata; current state is %s' %
                marker['state'])

        endpoint = str(endpoint).strip() if endpoint is not None else ''
        if not endpoint or endpoint.count('+') > 1:
            raise ObserverIdentityError('invalid standalone loopback SQL endpoint: %s' % endpoint)
        address, plus, rpc_port = endpoint.partition('+')
        raw_ip, separator, sql_port = address.rpartition(':')
        if not separator or not raw_ip or not sql_port.isdigit() or (plus and not rpc_port.isdigit()):
            raise ObserverIdentityError('invalid standalone loopback SQL endpoint: %s' % endpoint)

        server = cls._server(cluster_config)
        server_config = cluster_config.get_server_conf(server)
        if raw_ip not in (marker['ip'], server.ip):
            raise ObserverIdentityError(
                'standalone loopback SQL endpoint IP mismatch: expected %s or %s, got %s' % (
                    marker['ip'], server.ip, raw_ip))
        expected_sql_port = server_config.get('mysql_port')
        expected_rpc_port = server_config.get('rpc_port')
        if expected_sql_port is None or int(sql_port) != int(expected_sql_port):
            raise ObserverIdentityError(
                'standalone loopback SQL endpoint port mismatch: expected %s, got %s' % (
                    expected_sql_port, sql_port))
        if plus and (expected_rpc_port is None or int(rpc_port) != int(expected_rpc_port)):
            raise ObserverIdentityError(
                'standalone loopback RPC endpoint port mismatch: expected %s, got %s' % (
                    expected_rpc_port, rpc_port))
        return cls.externalize_endpoint(cluster_config, endpoint)

    @classmethod
    def reject_loopback_capability(cls, cluster_configs, capability):
        if isinstance(cluster_configs, dict):
            cluster_configs = cluster_configs.values()
        elif not isinstance(cluster_configs, (list, tuple, set)):
            cluster_configs = [cluster_configs]
        for cluster_config in cluster_configs:
            if cluster_config and (cls.is_loopback(cluster_config) or cls.is_explicit_legacy_loopback(cluster_config)):
                raise ObserverIdentityError(
                    '%s is not supported for standalone loopback identity; external endpoint adaptation is required' % capability)


class ClusterStatus(Enum):

    STATUS_RUNNING = 1  # running
    STATUS_STOPPED = 0   # stopped

class DeployConfigStatus(Enum):

    UNCHNAGE = 'unchange'
    NEED_RELOAD = 'need reload'
    NEED_RESTART = 'need restart'
    NEED_REDEPLOY = 'need redeploy'


class  DeployInstallMode(object):

    LN = 'ln'
    CP = 'cp'


class DeployInfo(object):

    def __init__(self, name, status, components=None, config_status=DeployConfigStatus.UNCHNAGE, create_date=None):
        self.status = status
        self.name = name
        self.components = components if components else {}
        self.config_status = config_status
        self.create_date = create_date

    def __str__(self):
        info = ['%s (%s)' % (self.name, self.status.value)]
        for name in self.components:
            info.append('%s-%s' % (name, self.components[name]))
        return '\n'.join(info)


class DeployConfig(SafeStdio):

    def __init__(self, yaml_path, yaml_loader=yaml, inner_config=None, config_parser_manager=None, config_encrypted=None, stdio=None):
        self._user = None
        self.unuse_lib_repository = False
        self.auto_create_tenant = False
        self._inner_config = inner_config
        self.components = OrderedDict()
        self._src_data = None
        self._need_encrypt_dump = False
        self._config_encrypted = config_encrypted
        self.name = os.path.split(os.path.split(yaml_path)[0])[-1]
        self.yaml_path = yaml_path
        self.yaml_loader = yaml_loader
        self.config_parser_manager = config_parser_manager if config_parser_manager else DEFAULT_CONFIG_PARSER_MANAGER
        self.stdio = stdio
        self._ignore_include_error = False
        if self.config_parser_manager is None:
            raise ParserError('ConfigParserManager Not Set')
        self._load()
        self._added_components = []
        self._changed_components = []
        self._removed_components = set()
        self._do_not_dump = False
        self._mem_mode = False
        self._tmp_user_password = None
        self._auto_decrypt_password()

    def __deepcopy__(self, memo):
        deploy_config = self.__class__(self.yaml_path, self.yaml_loader, self._inner_config, self.config_parser_manager, self.stdio)
        for component_name in self.components:
            deploy_config.components[component_name] = deepcopy(self.components[component_name])
        return deploy_config

    def set_undumpable(self):
        self._do_not_dump = True

    def set_dumpable(self):
        self._do_not_dump = False

    def enable_mem_mode(self):
        self._mem_mode = True

    def disable_mem_mode(self):
        self._mem_mode = False

    def set_config_unencrypted(self):
        self._config_encrypted = False

    def disable_encrypt_dump(self):
        self._need_encrypt_dump = False

    def enable_encrypt_dump(self):
        self._need_encrypt_dump = True

    @property
    def sorted_components(self):
        available_depends = list(self.components.keys())
        unsort_components = available_depends
        sorted_components = []
        while unsort_components:
            components = unsort_components
            unsort_components = []
            for component in components:
                cluster_config = self.components[component]
                for component_name in cluster_config.depends:
                    if component_name not in available_depends:
                        continue
                    if component_name not in sorted_components:
                        unsort_components.append(component)
                        break
                else:
                    sorted_components.append(component)
        return sorted_components


    @property
    def user(self):
        return self._user

    @property
    def inner_config(self):
        return self._inner_config

    @inner_config.setter
    def inner_config(self, inner_config):
        if inner_config:
            def get_inner_config(component_name):
                return inner_config.get_component_config(component_name)
        else:
            def get_inner_config(component_name):
                return ComponentInnerConfig(component_name, {})

        self._inner_config = inner_config
        base_dir = self.get_base_dir()
        for component_name in self.components:
            cluster_config = self.components[component_name]
            cluster_config.apply_inner_config(get_inner_config(component_name))
            cluster_config.set_base_dir(base_dir)

    @property
    def added_components(self):
        if self._added_components:
            return self._added_components
        elif self._changed_components or self._removed_components:
            # It's means that the components have been changed, so must not be added
            return []
        else:
            # Maybe the deploy is new, so all components are added
            return self.components.keys()
        
    @property
    def changed_components(self):
        return self._changed_components

    @property
    def removed_components(self):
        return self._removed_components

    def get_added_servers(self, component_name):
        if component_name not in self.components:
            raise Exception('No such component {}'.format(component_name))
        return self.components[component_name].added_servers

    def set_unuse_lib_repository(self, status):
        if self.unuse_lib_repository != status:
            self.unuse_lib_repository = status
            self._src_data['unuse_lib_repository'] = status
            return self._dump()
        return True

    def set_auto_create_tenant(self, status):
        if self.auto_create_tenant != status:
            self.auto_create_tenant = status
            self._src_data['auto_create_tenant'] = status
            return self._dump()
        return True

    def update_component_info(self, repository):
        component = repository.name
        if component not in self.components:
            return False
        ori_data = self._src_data[component]
        src_data = deepcopy(ori_data)

        if 'package_hash' in src_data:
            src_data['package_hash'] = repository.hash
        if 'version' in src_data:
            src_data['version'] = repository.version
        if 'release' in src_data:
            src_data['release'] = repository.release
        if src_data.get('type') == 'docker':
            src_data['tag'] = repository.version
        elif 'tag' in src_data:
            del src_data['tag']

        self._src_data[component] = src_data
        if self._dump():
            cluster_config = self.components[component]
            cluster_config.package_hash = repository.hash
            cluster_config.version = repository.version
            cluster_config.release = repository.release
            cluster_config.tag = None
            return True
        self._src_data[component] = ori_data
        return False

    def _update_user_password(self):
        try:
            for key in self._src_data:
                if key == 'user':
                    self._src_data[key]['password'] = self.user.password
        except:
            self.stdio.exception()

    def _load(self):
        try:
            with open(self.yaml_path, 'rb') as f:
                depends = {}
                self._src_data = self.yaml_loader.load(f)
                for key in self._src_data:
                    if key == 'user':
                        self.set_user_conf(UserConfig(
                            ConfigUtil.get_value_from_dict(self._src_data[key], 'username'),
                            ConfigUtil.get_value_from_dict(self._src_data[key], 'password'),
                            ConfigUtil.get_value_from_dict(self._src_data[key], 'key_file'),
                            ConfigUtil.get_value_from_dict(self._src_data[key], 'port', 0, int),
                            ConfigUtil.get_value_from_dict(self._src_data[key], 'timeout', 0, int),
                        ))
                    elif key == 'unuse_lib_repository':
                        self.unuse_lib_repository = self._src_data['unuse_lib_repository']
                    elif key == 'auto_create_tenant':
                        self.auto_create_tenant = self._src_data['auto_create_tenant']
                    elif issubclass(type(self._src_data[key]), dict):
                        self._add_component(key, self._src_data[key])
                        depends[key] = self._src_data[key].get('depends', [])
                for comp in depends:
                    conf = self.components[comp]
                    for name in depends[comp]:
                        if depends[comp] is None:
                            continue
                        if name == comp:
                            continue
                        if name in self.components:
                            conf.add_depend(name, self.components[name]) 
        except ReceiversConfigError as e:
            self.stdio.error(str(e))
            sys.exit()
        except:
            self.stdio.exception()
        if not self.user:
            self.set_user_conf(UserConfig())

    def _auto_decrypt_password(self):
        if not self._inner_config:
            return True
        if self._config_encrypted is None:
            if COMMAND_ENV.get(const.ENCRYPT_PASSWORD) == '1':
                self._config_encrypted = True
            if not bool(self._inner_config.get_global_config(const.ENCRYPT_PASSWORD)):
                self.stdio.verbose("auto_decrypt_password: deploy is not encrypted")
                self._config_encrypted = False
        if self._config_encrypted and bool(self._inner_config.get_global_config(const.ENCRYPT_PASSWORD)):
            self.change_deploy_config_password(False, False)
            self._need_encrypt_dump = True
        elif not self._config_encrypted and COMMAND_ENV.get(const.ENCRYPT_PASSWORD) == '1':
            self._need_encrypt_dump = True

    def _encrypt_password_before_dump(self):
        if not self._inner_config:
            return True
        if self._need_encrypt_dump and COMMAND_ENV.get(const.ENCRYPT_PASSWORD) == '1' and not self._config_encrypted:
            if bool(self._inner_config.get_global_config(const.ENCRYPT_PASSWORD)):
                change_deploy_encrypt = False
            else:
                change_deploy_encrypt = True
            enable_mem_mode = False
            if self._mem_mode:
                enable_mem_mode = True
                self._mem_mode = False
            self.change_deploy_config_password(True, change_deploy_encrypt)
            if enable_mem_mode:
                self._mem_mode = True
            self._config_encrypted = True
        self._update_user_password()

    def scale_out(self, config_path):
        ret = True
        depends = {}
        try:
            with FileUtil.open(config_path, 'rb') as f:
                source_data = self.yaml_loader.load(f)
                for key in source_data:
                    if key in ['user', 'unuse_lib_repository', 'auto_create_tenant']:
                        self.stdio.error(err.EC_COMPONENT_CHANGE_CONFIG.format(message=key))
                        ret = False
                    elif issubclass(type(source_data[key]), dict):
                        new_depends = source_data[key].get('depends', [])
                        if key not in self.components:
                            self.stdio.error(err.EC_COMPONENT_NOT_EXISTS.format(component=key))
                            ret = False
                            break
                        if new_depends and new_depends != self.components[key].depends:
                            self.stdio.error(err.EC_COMPONENT_CHANGE_CONFIG.format(message='depends:{}'.format(key)))
                            ret = False
                        # temp _depends
                        depends[key] = self.components[key].depends

                    if not self._merge_component(key, source_data[key]):
                        ret = False

                for comp in depends:
                    conf = self.components[comp]
                    for name in depends[comp]:
                        if name == comp:
                            continue
                        if name in self.components:
                            conf.add_depend(name, self.components[name])     
        except Exception as e:
            self.stdio.exception(e)
            ret = False
        return ret

    def add_components(self, config_path, ignore_exist=False):
        ret = True
        depends = {}
        try:
            with FileUtil.open(config_path, 'rb') as f:
                source_data = self.yaml_loader.load(f)
                for key in source_data:
                    if key in ['user', 'unuse_lib_repository', 'auto_create_tenant']:
                        self.stdio.error(err.EC_COMPONENT_CHANGE_CONFIG.format(message=key))
                        ret = False
                    elif issubclass(type(source_data[key]), dict):
                        if key in self.components:
                            if ignore_exist:
                                continue
                            self.stdio.error(err.EC_COMPONENT_EXISTS.format(component=key))
                            ret = False
                            continue
                        self._add_component(key, source_data[key])
                        if not self.update_component(self.components[key]):
                            self.stdio.error(err.EC_COMPONENT_FAIL_TO_UPDATE_CONFIG.format(component=key))
                            ret = False
                        depends[key] = source_data[key].get('depends', [])
                        self._added_components.append(key)
        except Exception as e:
            self.stdio.exception(e)
            ret = False

        for comp in depends:
            for name in depends[comp]:
                self.add_depend_for_component(comp, name, save=False)
        return ret

    def del_components(self, components, dryrun=False):
        ret = True
        src_data = deepcopy(self._src_data) if dryrun else self._src_data
        component_map = deepcopy(self.components) if dryrun else self.components
        for del_comp in components:
            if del_comp not in component_map:
                self.stdio.error(err.EC_COMPONENT_NOT_EXISTS.format(component=del_comp))
                ret = False
                continue
            del component_map[del_comp]
            del src_data[del_comp]
            self.removed_components.add(del_comp)
        for comp_name in component_map:
            for del_comp in components:
                if del_comp in component_map[comp_name].depends:
                    self.stdio.error(err.EC_COMPONENT_REMOVE_DEPENDS.format(component1=del_comp, component2=comp_name))
                    ret = False
        if not component_map:
            self.stdio.error(err.EC_COMPONENT_NO_REMAINING_COMPS)
            ret = False
        return ret

    def allow_include_error(self):
        self.stdio.verbose("allow include file not exists")
        self._ignore_include_error = True

    def load_include_file(self, path):
        if not os.path.isabs(path):
            raise Exception("`{}` need to use absolute path. If you want to use relative paths, please enable developer mode "
            "and set environment variables {}".format('include', ENV_BASE_DIR))
        if os.path.isfile(path):
            with open(path, 'rb') as f:
                return self.yaml_loader.load(f)
        else:
            if self._ignore_include_error:
                self.stdio.warn("include file: {} not found, some configurations may be lost".format(path))
                return {}
            else:
                raise Exception('Not such file: %s' % path)

    def _separate_config(self):
        if self.inner_config:
            for component_name in self.components:
                cluster_config = self.components[component_name]
                src_data = self._src_data[component_name]
                parser = cluster_config.parser
                if parser:
                    inner_config = parser.extract_inner_config(cluster_config, src_data)
                    self.inner_config.update_component_config(component_name, inner_config)

    def _dump_inner_config(self):
        if self.inner_config:
            self._separate_config()
            return self.inner_config.dump()
        return True

    def dump_inner_config(self):
        return self._dump_inner_config()

    def _dump(self):
        if self._do_not_dump:
            raise Exception("Cannot dump because flag DO NOT DUMP exists.")
        self._encrypt_password_before_dump()
        try:
            if not self._dump_inner_config():
                return False
            with open(self.yaml_path, 'w') as f:
                self.yaml_loader.dump(self._src_data, f)
            return True
        except:
            import logging
            logging.exception('')
            pass
            return False
        finally:
            if self._need_encrypt_dump and COMMAND_ENV.get(const.ENCRYPT_PASSWORD) == '1' and self._config_encrypted:
                self.change_deploy_config_password(False, False)
                self._config_encrypted = False
                self._need_encrypt_dump = True

    def dump(self):
        return self._dump()

    def _update_global_inner_config(self, key, value, save=True):
        if self.inner_config:
            self.inner_config.update_global_config(key, value)
        return self._dump_inner_config() if save else True

    def _get_global_inner_config(self, key, default=None):
        if self.inner_config:
            return self.inner_config.get_global_config(key, default)
        return default

    def set_base_dir(self, path, save=True):
        if path and not os.path.isabs(path):
            raise Exception('%s is not an absolute path' % path)
        if self._update_global_inner_config(InnerConfigKeywords.DEPLOY_BASE_DIR, path, save=save):
            for component_name in self.components:
                cluster_config = self.components[component_name]
                cluster_config.set_base_dir(path)
            return True
        return False

    def get_base_dir(self):
        return self._get_global_inner_config(InnerConfigKeywords.DEPLOY_BASE_DIR, '')

    def set_deploy_install_mode(self, mode, save=True):
        return self._update_global_inner_config(InnerConfigKeywords.DEPLOY_INSTALL_MODE, mode, save=save)

    def get_deploy_install_mode(self):
        return self._get_global_inner_config(InnerConfigKeywords.DEPLOY_INSTALL_MODE, DeployInstallMode.CP)

    def enable_ln_install_mode(self, save=True):
        return self.set_deploy_install_mode(DeployInstallMode.LN, save=save)

    def enable_cp_install_mode(self, save=True):
        return self.set_deploy_install_mode(DeployInstallMode.CP, save=save)

    def is_ln_install_mode(self):
        return self.get_deploy_install_mode() == DeployInstallMode.LN

    def is_cp_install_mode(self):
        return self.get_deploy_install_mode() == DeployInstallMode.CP

    def set_user_conf(self, conf):
        self._user = conf

    def add_depend_for_component(self, component_name, depend_component_name, save=True):
        if component_name not in self.components:
            return False
        if depend_component_name not in self.components:
            return False
        cluster_config = self.components[component_name]
        if depend_component_name in cluster_config.depends:
            return True
        cluster_config.add_depend(depend_component_name, self.components[depend_component_name])
        component_config = self._src_data[component_name]
        if 'depends' not in component_config:
            component_config['depends'] = []
        component_config['depends'].append(depend_component_name)
        return self.dump() if save else True

    def del_depend_for_component(self, component_name, depend_component_name, save=True):
        if component_name not in self.components:
            return False
        if depend_component_name not in self.components:
            return False
        cluster_config = self.components[component_name]
        if depend_component_name not in cluster_config.depends:
            return True
        cluster_config.del_depend(depend_component_name, depend_component_name)
        component_config = self._src_data[component_name]
        component_config['depends'] = cluster_config.depends
        return self.dump() if save else True

    def update_component_server_conf(self, component_name, server, key, value, save=True):
        if self._mem_mode: 
            return True
        if component_name not in self.components:
            return False
        cluster_config = self.components[component_name]
        if server not in cluster_config.servers:
            return False
        component_config = cluster_config.parser.get_server_src_conf(cluster_config, self._src_data[component_name], server)
        component_config[key] = value
        return self.dump() if save else True

    def update_component_global_conf(self, component_name, key, value, save=True):
        if self._mem_mode:
            return True
        if component_name not in self.components:
            return False
        cluster_config = self.components[component_name]
        component_config = cluster_config.parser.get_global_src_conf(cluster_config, self._src_data[component_name])
        component_config[key] = value
        return self.dump() if save else True

    def _set_component(self, cluster_config):
        cluster_config.set_deploy_config(self)
        if self.inner_config:
            inner_config = self.inner_config.get_component_config(cluster_config.name)
            if inner_config:
                cluster_config.apply_inner_config(inner_config)
        self.components[cluster_config.name] = cluster_config

    def update_component(self, cluster_config):
        component_name = cluster_config.name
        if cluster_config.parser:
            parser = cluster_config.parser
        else:
            conf = self._src_data.get('component_name', {})
            style = conf.get('style', 'default')
            parser = self.config_parser_manager.get_parser(component_name, style)

        conf = parser.from_cluster_config(cluster_config)
        if component_name in self.components:
            self.components[component_name].set_deploy_config(None)
        cluster_config = deepcopy(cluster_config)
        cluster_config.apply_inner_config(conf['inner_config'])
        global_conf = cluster_config.get_global_conf()
        if component_name == const.COMP_ALERTMANAGER:
            for receiver in global_conf.get('receivers'):
                receiver_conf = conf['config'].get(receiver)
                if receiver_conf:
                    cluster_config.update_receivers_conf(receiver, receiver_conf)
        if self.inner_config:
            self.inner_config.update_component_config(component_name, conf['inner_config'])
        self._src_data[component_name] = conf['config']
        self._set_component(cluster_config)
        return True

    def _add_component(self, component_name, conf):
        self._set_component(self._parse_cluster_config(component_name, conf))

    def _parse_cluster_config(self, component_name, conf):
        parser = self.config_parser_manager.get_parser(component_name, conf.get('style'))
        return parser.to_cluster_config(component_name, conf)

    def _merge_component(self, component_name, conf):
        if component_name not in self.components:
            self.stdio.error('No such component {}'.format(component_name))
            return False
        parser = self.config_parser_manager.get_parser(component_name, conf.get('style'))
        cluster_config = self.components[component_name]
        if parser != cluster_config.parser:
            self.stdio.error('The style of the added configuration do not match the style of the existing cluster')
            return False
        src_conf = parser.from_cluster_config(cluster_config)

        global_attr = {}
        if ComponentInnerConfig.COMPONENT_GLOBAL_ATTRS in src_conf['inner_config']:
            global_attr = deepcopy(src_conf['inner_config'][(ComponentInnerConfig.COMPONENT_GLOBAL_ATTRS)])
        try:
            merged_cluster_config = parser.merge_config(component_name, src_conf['config'], conf)
            self._src_data[component_name] = src_conf['config']
            self._set_component(merged_cluster_config)
        except Exception as e:
            self.stdio.exception(err.EC_COMPONENT_FAILED_TO_MERGE_CONFIG.format(message=str(e)))
            return False
        
        cluster_config = self.components[component_name]
        for k in global_attr:
            v = global_attr.get(k)
            cluster_config.update_component_attr(k, v, save=False)
        self._changed_components.append(component_name)
        return True

    def change_component_config_style(self, component_name, style):
        if component_name not in self.components:
            return False

        parser = self.config_parser_manager.get_parser(component_name, style)
        cluster_config = self.components[component_name]
        if cluster_config.parser != parser:
            new_config = parser.from_cluster_config(cluster_config)
            self._add_component(component_name, new_config)
            self.components[component_name].apply_inner_config(new_config['inner_config'])
            if self.inner_config:
                self.inner_config.update_component_config(component_name, new_config['inner_config'])
            self._src_data[component_name] = new_config['config']
        return True

    def get_all_password_path(self, global_config, password_paths=[], component=None, parent_key=None):
        pattern = r'password'
        pattern1 = r'passwd'
        for key, value in global_config.items():
            if parent_key:
                current_key = f"{parent_key}.{key}"
            else:
                current_key = key

            if isinstance(value, dict):
                self.get_all_password_path(value, password_paths, component, current_key)
            else:
                value = str(value)
                if isinstance(key, str) and isinstance(value, str) and (re.findall(pattern, key, re.IGNORECASE) or re.findall(pattern1, key, re.IGNORECASE)):
                    self.stdio.verbose(f"find pwd key: {current_key}")
                    password_paths.append(current_key)
                if component in [const.COMP_PROMETHEUS, const.COMP_ALERTMANAGER] and parent_key == 'basic_auth_users':
                    self.stdio.verbose(f"find pwd key: {key}")
                    password_paths.append(current_key)
        return password_paths

    def update_password_in_global_config(self, global_config, path, key, enable_encrypt):
        current_key = path[0]
        if len(path) == 1:
            if enable_encrypt:
                self.stdio.verbose(f"encrypt pwd-key: {current_key}")
                global_config[current_key] = aes_encrypt(str(global_config[current_key]), key)
            else:
                self.stdio.verbose(f"decrypt pwd-key: {current_key}")
                global_config[current_key] = aes_decrypt(global_config[current_key], key)
        else:
            if current_key in global_config and isinstance(global_config[current_key], dict):
                self.update_password_in_global_config(global_config[current_key], path[1:], key, enable_encrypt)

    def change_deploy_config_password(self, enable_encrypt, change_deploy_encrypt=True, first_encrypt=False):
        class ExcludePassword:
            def __init__(self, ob_param: str, comps: list):
                self.ob_param = ob_param
                self.comps = comps

        if COMMAND_ENV.get(const.ENCRYPT_PASSWORD) != '1' and not first_encrypt:
            return True
        deploy_encrypt_enable = self.inner_config.get_global_config(const.ENCRYPT_PASSWORD) or False
        if enable_encrypt == deploy_encrypt_enable == self._config_encrypted:
            return True
        if not enable_encrypt and not self._config_encrypted:
            self._need_encrypt_dump = False
        else:
            ob_global_config = {}
            cluster_id = ''
            for component in const.COMPS_OB:
                if component in self.components.keys():
                    cluster_config = self.components[component]
                    global_config = cluster_config.get_global_conf()
                    ob_global_config = global_config
                    cluster_id = str(global_config['cluster_id']) if 'cluster_id' in global_config else ''
            key = string_to_md5_32bytes(self.name + cluster_id).encode('utf-8')
            self.stdio.verbose(f"encrypt key: {key}")
            if self.user.password:
                if enable_encrypt:
                    self.user.password = aes_encrypt(str(self.user.password), key)
                else:
                    self.user.password = aes_decrypt(self.user.password, key)

            exclude_pwd = {"ocp_meta_password": ExcludePassword("ocp_meta_password", const.COMPS_OCP)}
            for component, cluster_config in self.components.items():
                self.stdio.verbose(f"change {component} pwd encrypt.")
                password_paths = []
                global_config = cluster_config.get_global_conf()
                self.get_all_password_path(global_config, password_paths, component)
                change_global_config = deepcopy(global_config)
                for password_path in password_paths:
                    if password_path in exclude_pwd and component in exclude_pwd[password_path].comps:
                        origin_global_config = cluster_config.get_original_global_conf()
                        if ob_global_config.get(exclude_pwd[password_path].ob_param) and not origin_global_config.get(password_path):
                            continue
                    password_path_keys = password_path.split('.')
                    self.update_password_in_global_config(change_global_config, password_path_keys, key, enable_encrypt)
                    cluster_config.update_global_conf(password_path_keys[0], change_global_config[password_path_keys[0]], save=False)
            self._config_encrypted = enable_encrypt
        change_deploy_encrypt and self.inner_config.update_global_config(const.ENCRYPT_PASSWORD, enable_encrypt)


class Deploy(object):

    DEPLOY_STATUS_FILE = '.data'
    DEPLOY_YAML_NAME = 'config.yaml'
    INNER_CONFIG_NAME = 'inner_config.yaml'
    UPRADE_META_NAME = '.upgrade'

    def __init__(self, config_dir, config_parser_manager=None, stdio=None):
        self.config_dir = config_dir
        self.name = os.path.split(config_dir)[1]
        self._info = None
        self._config = None
        self.stdio = stdio
        self.config_parser_manager = config_parser_manager
        self._uprade_meta = None
        self._config_encrypted = None

    def set_config_decrypted(self):
        self._config_encrypted = False

    def use_model(self, name, repository, dump=True):
        self.deploy_info.components[name] = {
            'hash': repository.hash,
            'version': repository.version
        }
        return self.dump_deploy_info() if dump else True

    def unuse_model(self, name, dump=True):
        del self.deploy_info.components[name]
        return self.dump_deploy_info() if dump else True

    @staticmethod
    def get_deploy_file_path(path):
        return os.path.join(path, Deploy.DEPLOY_STATUS_FILE)

    @staticmethod
    def get_deploy_yaml_path(path):
        return os.path.join(path, Deploy.DEPLOY_YAML_NAME)

    @staticmethod
    def get_upgrade_meta_path(path):
        return os.path.join(path, Deploy.UPRADE_META_NAME)

    @staticmethod
    def get_inner_config_path(path):
        return os.path.join(path, Deploy.INNER_CONFIG_NAME)

    @staticmethod
    def get_temp_deploy_yaml_path(path):
        return os.path.join(path, 'tmp_%s' % Deploy.DEPLOY_YAML_NAME)

    @property
    def deploy_info(self):
        if self._info is None:
            try:
                path = self.get_deploy_file_path(self.config_dir)
                with open(path, 'rb') as f:
                    data = yaml.load(f)
                    self._info = DeployInfo(
                        data['name'],
                        getattr(DeployStatus, data['status'], DeployStatus.STATUS_CONFIGURED),
                        ConfigUtil.get_value_from_dict(data, 'components', OrderedDict()),
                        getattr(DeployConfigStatus, ConfigUtil.get_value_from_dict(data, 'config_status', '_'), DeployConfigStatus.UNCHNAGE),
                        ConfigUtil.get_value_from_dict(data, 'create_date', None),
                    )
            except:
                self._info = DeployInfo(self.name, DeployStatus.STATUS_CONFIGURED)
        return self._info

    def _load_deploy_config(self, path):
        yaml_loader = YamlLoader(stdio=self.stdio)
        inner_config = InnerConfig(self.get_inner_config_path(self.config_dir), yaml_loader=yaml_loader)
        deploy_config = DeployConfig(path, yaml_loader=yaml_loader, inner_config=inner_config, config_parser_manager=self.config_parser_manager, config_encrypted=self._config_encrypted, stdio=self.stdio)
        deploy_info = self.deploy_info
        for component_name in deploy_info.components:
            if component_name not in deploy_config.components:
                continue
            config = deploy_info.components[component_name]
            cluster_config = deploy_config.components[component_name]
            if 'version' in config and config['version']:
                cluster_config.version = config['version']
            if 'hash' in config and config['hash']:
                cluster_config.package_hash = config['hash']
        return deploy_config

    @property
    def temp_deploy_config(self):
        path = self.get_temp_deploy_yaml_path(self.config_dir)
        return self._load_deploy_config(path)

    @property
    def deploy_config(self):
        if self._config is None:
            path = self.get_deploy_yaml_path(self.config_dir)
            self._config = self._load_deploy_config(path)
        return self._config

    def _get_uprade_meta(self):
        if self._uprade_meta is None and self.deploy_info.status == DeployStatus.STATUS_UPRADEING:
            try:
                path = self.get_upgrade_meta_path(self.config_dir)
                with open(path) as f:
                    self._uprade_meta = yaml.load(f)
            except:
                self.stdio and getattr(self.stdio, 'exception', print)('fail to load uprade meta data')
        return self._uprade_meta

    @property
    def upgrade_ctx(self):
        uprade_meta = self._get_uprade_meta()
        return uprade_meta.get('uprade_ctx') if uprade_meta else None

    @property
    def upgrading_component(self):
        uprade_meta = self._get_uprade_meta()
        return uprade_meta.get('component') if uprade_meta else None

    def apply_temp_deploy_config(self):
        self.stdio and getattr(self.stdio, 'verbose', print)('%s apply temp config' % self.name)
        src_yaml_path = self.get_temp_deploy_yaml_path(self.config_dir)
        target_src_path = self.get_deploy_yaml_path(self.config_dir)
        try:
            FileUtil.move(src_yaml_path, target_src_path)
            self._config = None
            self.update_deploy_config_status(DeployConfigStatus.UNCHNAGE)
            return True
        except Exception as e:
            self.stdio and getattr(self.stdio, 'exception', print)('mv %s to %s failed, error: \n%s' % (src_yaml_path, target_src_path, e))
        return False

    def dump_deploy_info(self):
        path = self.get_deploy_file_path(self.config_dir)
        self.stdio and getattr(self.stdio, 'verbose', print)('dump deploy info to %s' % path)
        try:
            with open(path, 'w') as f:
                data = {
                    'name': self.deploy_info.name,
                    'components': self.deploy_info.components,
                    'status': self.deploy_info.status.name,
                    'config_status': self.deploy_info.config_status.name,
                    'create_date': self.deploy_info.create_date,
                }
                yaml.dump(data, f)
            return True
        except:
            self.stdio and getattr(self.stdio, 'exception', print)('dump deploy info to %s failed' % path)
        return False

    def _update_deploy_status(self, status):
        old = self.deploy_info.status
        self.deploy_info.status = status
        if old == DeployStatus.STATUS_DEPLOYED and status == DeployStatus.STATUS_RUNNING:
            self.deploy_info.create_date = datetime.now().strftime('%Y-%m-%d')
        if self.dump_deploy_info():
            return True
        self.deploy_info.status = old
        return False

    def _update_deploy_config_status(self, status):
        old = self.deploy_info.config_status
        self.deploy_info.config_status = status
        if self.dump_deploy_info():
            return True
        self.deploy_info.config_status = old
        return False

    def _dump_upgrade_meta_data(self):
        path = self.get_upgrade_meta_path(self.config_dir)
        self.stdio and getattr(self.stdio, 'verbose', print)('dump upgrade meta data to %s' % path)
        try:
            if self._uprade_meta:
                with open(path, 'wb') as f:
                    yaml.dump(self._uprade_meta, f)
            else:
                FileUtil.rm(path, self.stdio)
            return True
        except:
            self.stdio and getattr(self.stdio, 'exception', print)('dump upgrade meta data to %s failed' % path)
        return False

    def start_upgrade(self, component, **uprade_ctx):
        if self.deploy_info.status != DeployStatus.STATUS_RUNNING:
            return False
        self._uprade_meta = {
            'component': component,
            'uprade_ctx': uprade_ctx
        }
        if self._dump_upgrade_meta_data() and self._update_deploy_status(DeployStatus.STATUS_UPRADEING):
            return True
        self._uprade_meta = None
        return False

    def update_upgrade_ctx(self, **uprade_ctx):
        if self.deploy_info.status != DeployStatus.STATUS_UPRADEING:
            return False
        uprade_meta = deepcopy(self._get_uprade_meta())
        self._uprade_meta['uprade_ctx'].update(uprade_ctx)
        if self._dump_upgrade_meta_data():
            return True
        self._uprade_meta = uprade_meta
        return False

    def update_component_repository(self, repository):
        if not self.deploy_config.update_component_info(repository):
            return False
        self.use_model(repository.name, repository)
        return True

    def stop_upgrade(self, dest_repository=None):
        if self._update_deploy_status(DeployStatus.STATUS_RUNNING):
            self._uprade_meta = None
            self._dump_upgrade_meta_data()
            if dest_repository:
                self.update_component_repository(dest_repository)
            return True
        return False

    def update_deploy_status(self, status):
        if isinstance(status, DeployStatus):
            if self._update_deploy_status(status):
                if DeployStatus.STATUS_DESTROYED == status:
                    self.deploy_info.components = {}
                    self.dump_deploy_info()
                return True
        return False

    def update_deploy_config_status(self, status):
        if isinstance(status, DeployConfigStatus):
            return self._update_deploy_config_status(status)
        return False

    def effect_tip(self):
        cmd_map = {
            DeployConfigStatus.NEED_RELOAD: 'obd cluster reload %s' % self.name,
            DeployConfigStatus.NEED_RESTART: 'obd cluster restart %s --wp' % self.name,
            DeployConfigStatus.NEED_REDEPLOY: 'obd cluster redeploy %s' % self.name,
        }
        if self.deploy_info.config_status in cmd_map:
            return '\nUse `%s` to make changes take effect.' % cmd_map[self.deploy_info.config_status]
        return ''


class ConfigParserManager(Manager):

    RELATIVE_PATH = 'config_parser/'

    def __init__(self, home_path, stdio=None):
        super(ConfigParserManager, self).__init__(home_path, stdio)
        self.global_parsers = {
            'default': DefaultConfigParser,
        }
        self.component_parsers = {}

    def _format_paraser_name(self, style):
        style = style.title()
        return '%sConfigParser' % style.replace('-', '').replace(' ', '').replace('_', '')

    def _load_paraser(self, lib_path, style):
        from tool import DynamicLoading
        module_name = '%s_config_parser' % style
        file_name = '%s.py' % module_name
        path = os.path.join(lib_path, file_name)
        if os.path.isfile(path):
            DynamicLoading.add_lib_path(lib_path)
            self.stdio and getattr(self.stdio, 'verbose', 'print')('load config parser: %s' % path)
            module = DynamicLoading.import_module(module_name, self.stdio)
            clz_name = self._format_paraser_name(style)
            try:
                return getattr(module, clz_name)
            except:
                self.stdio and getattr(self.stdio, 'exception', 'print')('')
                return None
            finally:
                DynamicLoading.remove_lib_path(lib_path)
        else:
            self.stdio and getattr(self.stdio, 'verbose', 'print')('No config parser: %s' % path)
            return None

    def _get_component_parser(self, component, style):
        if component not in self.component_parsers:
            self.component_parsers[component] = {}
        component_parsers = self.component_parsers[component]
        if style not in component_parsers:
            lib_path = os.path.join(self.path, component)
            component_parsers[style] = self._load_paraser(lib_path, style)
        return component_parsers[style]

    def _get_global_parser(self, style):
        if style not in self.global_parsers:
            self.global_parsers[style] = self._load_paraser(self.path, style)
        return self.global_parsers[style]

    def get_parser(self, component='', style=''):
        if not style or style == 'default':
            return self.global_parsers['default']
        if component:
            parser = self._get_component_parser(component, style)
            if parser:
                return parser
        parser = self._get_global_parser(style)
        if not parser:
            raise ParserError('Unsupported configuration style: %s %s' % (component, style))
        return parser


class DeployManager(Manager):

    RELATIVE_PATH = 'cluster/'
    
    def __init__(self, home_path, lock_manager=None, stdio=None):
        super(DeployManager, self).__init__(home_path, stdio)
        self.lock_manager = lock_manager
        self.config_parser_manager = ConfigParserManager(home_path, stdio)

    def _lock(self, name, read_only=False):
        if self.lock_manager:
            if read_only:
                return self.lock_manager.deploy_sh_lock(name)
            else:
                return self.lock_manager.deploy_ex_lock(name)
        return True

    def get_deploy_configs(self, read_only=True):
        configs = []
        for name in os.listdir(self.path):
            path = os.path.join(self.path, name)
            if os.path.isdir(path):
                self._lock(name, read_only)
                configs.append(Deploy(path, config_parser_manager=self.config_parser_manager, stdio=self.stdio))
        return configs

    def get_deploy_config(self, name, read_only=False):
        self._lock(name, read_only)
        path = os.path.join(self.path, name)
        if os.path.isdir(path):
            return Deploy(path, config_parser_manager=self.config_parser_manager, stdio=self.stdio)
        return None

    def create_deploy_config(self, name, src_yaml_path):
        self._lock(name)
        config_dir = os.path.join(self.path, name)
        target_src_path = Deploy.get_deploy_yaml_path(config_dir)
        self._mkdir(config_dir)
        if FileUtil.copy(src_yaml_path, target_src_path, self.stdio):
            return Deploy(config_dir, config_parser_manager=self.config_parser_manager, stdio=self.stdio)
        else:
            self._rm(config_dir)
            return None
        
    def remove_deploy_config(self, name):
        self._lock(name)
        config_dir = os.path.join(self.path, name)
        self._rm(config_dir)