def get(hostname,
username=None,
fallback=None,
detect_sudo=True,
use_rhceph=False):
"""
Retrieve the module that matches the distribution of a ``hostname``. This
function will connect to that host and retrieve the distribution
information, then return the appropriate module and slap a few attributes
to that module defining the information it found from the hostname.
For example, if host ``node1.example.com`` is an Ubuntu server, the
``debian`` module would be returned and the following would be set::
module.name = 'ubuntu'
module.release = '12.04'
module.codename = 'precise'
:param hostname: A hostname that is reachable/resolvable over the network
:param fallback: Optional fallback to use if no supported distro is found
:param use_rhceph: Whether or not to install RH Ceph on a RHEL machine or
the community distro. Changes what host module is
returned for RHEL.
"""
conn = get_connection(
hostname,
username=username,
logger=logging.getLogger(hostname),
detect_sudo=detect_sudo
)
try:
conn.import_module(remotes)
except IOError as error:
if 'already closed' in getattr(error, 'message', ''):
raise RuntimeError('remote connection got closed, ensure ``requiretty`` is disabled for %s' % hostname)
distro_name, release, codename = conn.remote_module.platform_information()
if not codename or not _get_distro(distro_name):
raise exc.UnsupportedPlatform(
distro=distro_name,
codename=codename,
release=release)
machine_type = conn.remote_module.machine_type()
module = _get_distro(distro_name, use_rhceph=use_rhceph)
module.name = distro_name
module.normalized_name = _normalized_distro_name(distro_name)
module.normalized_release = _normalized_release(release)
module.distro = module.normalized_name
module.is_el = module.normalized_name in ['redhat', 'centos', 'fedora', 'scientific']
module.is_rpm = module.normalized_name in ['redhat', 'centos',
'fedora', 'scientific', 'suse']
module.is_deb = not module.is_rpm
module.release = release
module.codename = codename
module.conn = conn
module.machine_type = machine_type
module.init = module.choose_init(module)
module.packager = module.get_packager(module)
return module
def connect(args):
for hostname in args.hosts:
distro = hosts.get(hostname, username=args.username)
if not distro_is_supported(distro.normalized_name):
raise exc.UnsupportedPlatform(
distro.distro_name,
distro.codename,
distro.release
)
LOG.info(
'Distro info: %s %s %s',
distro.name,
distro.release,
distro.codename
)
LOG.info('assuming that a repository with Calamari packages is already configured.')
LOG.info('Refer to the docs for examples (http://ceph.com/ceph-deploy/docs/conf.html)')
rlogger = logging.getLogger(hostname)
# Emplace minion config prior to installation so that it is present
# when the minion first starts.
minion_config_dir = os.path.join('/etc/salt/', 'minion.d')
minion_config_file = os.path.join(minion_config_dir, 'calamari.conf')
rlogger.debug('creating config dir: %s' % minion_config_dir)
distro.conn.remote_module.makedir(minion_config_dir, [errno.EEXIST])
rlogger.debug(
'creating the calamari salt config: %s' % minion_config_file
)
distro.conn.remote_module.write_file(
minion_config_file,
('master: %s\n' % args.master).encode('utf-8')
)
distro.packager.install('salt-minion')
distro.packager.install('diamond')
# redhat/centos need to get the service started
if distro.normalized_name in ['redhat', 'centos']:
remoto.process.run(
distro.conn,
['chkconfig', 'salt-minion', 'on']
)
remoto.process.run(
distro.conn,
['service', 'salt-minion', 'start']
)
distro.conn.exit()
def _get_distro(distro, fallback=None):
distro = _normalized_distro_name(distro)
distributions = {
'debian': debian,
'ubuntu': debian,
'centos': centos,
'scientific': centos,
'redhat': centos,
'fedora': fedora,
'suse': suse,
}
try:
return distributions[distro]
except KeyError:
if fallback:
return _get_distro(fallback)
raise exc.UnsupportedPlatform(distro=distro, codename='')
def get(hostname, username=None, fallback=None):
"""
Retrieve the module that matches the distribution of a ``hostname``. This
function will connect to that host and retrieve the distribution
informaiton, then return the appropriate module and slap a few attributes
to that module defining the information it found from the hostname.
For example, if host ``node1.example.com`` is an Ubuntu server, the
``debian`` module would be returned and the following would be set::
module.name = 'ubuntu'
module.release = '12.04'
module.codename = 'precise'
:param hostname: A hostname that is reachable/resolvable over the network
:param fallback: Optional fallback to use if no supported distro is found
"""
conn = get_connection(hostname,
username=username,
logger=logging.getLogger(hostname))
try:
conn.import_module(remotes)
except IOError as error:
if 'already closed' in getattr(error, 'message', ''):
raise RuntimeError(
'remote connection got closed, ensure ``requiretty`` is disabled for %s'
% hostname)
distro_name, release, codename = conn.remote_module.platform_information()
if not codename or not _get_distro(distro_name):
raise exc.UnsupportedPlatform(distro=distro_name,
codename=codename,
release=release)
machine_type = conn.remote_module.machine_type()
module = _get_distro(distro_name)
module.name = distro_name
module.normalized_name = _normalized_distro_name(distro_name)
module.normalized_release = _normalized_release(release)
module.distro = module.normalized_name
module.release = release
module.codename = codename
module.conn = conn
module.machine_type = machine_type
module.init = module.choose_init()
return module
def get(hostname, username=None, fallback=None):
"""
Retrieve the module that matches the distribution of a ``hostname``. This
function will connect to that host and retrieve the distribution
informaiton, then return the appropriate module and slap a few attributes
to that module defining the information it found from the hostname.
For example, if host ``node1.example.com`` is an Ubuntu server, the
``debian`` module would be returned and the following would be set::
module.name = 'ubuntu'
module.release = '12.04'
module.codename = 'precise'
:param hostname: A hostname that is reachable/resolvable over the network
:param fallback: Optional fallback to use if no supported distro is found
"""
conn = get_connection(hostname,
username=username,
logger=logging.getLogger(hostname))
conn.import_module(remotes)
distro_name, release, codename = conn.remote_module.platform_information()
if not codename:
raise exc.UnsupportedPlatform(distro=distro, codename=codename)
machine_type = conn.remote_module.machine_type()
module = _get_distro(distro_name)
module.name = distro_name
module.release = release
module.codename = codename
module.conn = conn
module.machine_type = machine_type
module.init = lsb.choose_init(distro_name, codename)
return module
def get(hostname,
username=None,
fallback=None,
detect_sudo=True,
use_rhceph=False,
callbacks=None):
"""
Retrieve the module that matches the distribution of a ``hostname``. This
function will connect to that host and retrieve the distribution
information, then return the appropriate module and slap a few attributes
to that module defining the information it found from the hostname.
For example, if host ``node1.example.com`` is an Ubuntu server, the
``debian`` module would be returned and the following would be set::
module.name = 'ubuntu'
module.release = '12.04'
module.codename = 'precise'
:param hostname: A hostname that is reachable/resolvable over the network
:param fallback: Optional fallback to use if no supported distro is found
:param use_rhceph: Whether or not to install RH Ceph on a RHEL machine or
the community distro. Changes what host module is
returned for RHEL.
:params callbacks: A list of callables that accept one argument (the actual
module that contains the connection) that will be
called, in order at the end of the instantiation of the
module.
"""
conn = get_connection(hostname,
username=username,
logger=logging.getLogger(hostname),
detect_sudo=detect_sudo)
try:
#将需要在远端执行的代码载入远端
conn.import_module(remotes)
except IOError as error:
if 'already closed' in getattr(error, 'message', ''):
raise RuntimeError(
'remote connection got closed, ensure ``requiretty`` is disabled for %s'
% hostname)
#获取系统信息
distro_name, release, codename = conn.remote_module.platform_information()
if not codename or not _get_distro(distro_name):
#报错，不认识当前待安装的平台
raise exc.UnsupportedPlatform(distro=distro_name,
codename=codename,
release=release)
#获取系统体系
machine_type = conn.remote_module.machine_type()
module = _get_distro(distro_name, use_rhceph=use_rhceph)
module.name = distro_name
module.normalized_name = _normalized_distro_name(distro_name)
module.normalized_release = _normalized_release(release)
module.distro = module.normalized_name
module.is_el = module.normalized_name in [
'redhat', 'centos', 'fedora', 'scientific', 'oracle', 'virtuozzo'
]
module.is_rpm = module.normalized_name in [
'redhat', 'centos', 'fedora', 'scientific', 'suse', 'oracle',
'virtuozzo'
]
module.is_deb = module.normalized_name in ['debian', 'ubuntu'] #使用deb包
module.is_pkgtarxz = module.normalized_name in ['arch']
module.release = release
module.codename = codename
module.conn = conn
module.machine_type = machine_type
module.init = module.choose_init(module)
module.packager = module.get_packager(module)
# execute each callback if any
if callbacks:
for c in callbacks:
c(module)
return module
def connect(args):
cd_conf = getattr(args, 'cd_conf', None)
if not cd_conf:
raise RuntimeError(
'a ceph-deploy configuration is required but was not found')
repo_name = args.release or 'calamari-minion'
has_minion_repo = cd_conf.has_section(repo_name)
if not has_minion_repo:
raise RuntimeError('no calamari-minion repo found')
# We rely on the default for repo installs that does not
# install ceph unless specified otherwise
options = dict(cd_conf.items(repo_name))
for hostname in args.hosts:
distro = hosts.get(hostname, username=args.username)
if not distro_is_supported(distro.normalized_name):
raise exc.UnsupportedPlatform(distro.distro_name, distro.codename,
distro.release)
LOG.info('Distro info: %s %s %s', distro.name, distro.release,
distro.codename)
rlogger = logging.getLogger(hostname)
rlogger.info('installing calamari-minion package on %s' % hostname)
rlogger.info('adding custom repository file')
try:
distro.repo_install(
distro,
repo_name,
options.pop('baseurl'),
options.pop('gpgkey', ''), # will probably not use a gpgkey
**options)
except KeyError as err:
raise RuntimeError(
'missing required key: %s in config section: %s' %
(err, repo_name))
# Emplace minion config prior to installation so that it is present
# when the minion first starts.
minion_config_dir = os.path.join('/etc/salt/', 'minion.d')
minion_config_file = os.path.join(minion_config_dir, 'calamari.conf')
rlogger.debug('creating config dir: %s' % minion_config_dir)
distro.conn.remote_module.makedir(minion_config_dir, [errno.EEXIST])
rlogger.debug('creating the calamari salt config: %s' %
minion_config_file)
distro.conn.remote_module.write_file(minion_config_file,
'master: %s\n' % args.master)
distro.pkg.install(distro, 'salt-minion')
# redhat/centos need to get the service started
if distro.normalized_name in ['redhat', 'centos']:
process.run(distro.conn, ['chkconfig', 'salt-minion', 'on'])
process.run(distro.conn, ['service', 'salt-minion', 'start'])
distro.conn.exit()
