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()
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):
"""
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.packager = module.get_packager(module)
return module
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 mon_create_initial(args):
mon_initial_members = get_mon_initial_members(args, error_on_empty=True)
# create them normally through mon_create
args.mon = mon_initial_members
mon_create(args)
# make the sets to be able to compare late
mon_in_quorum = set([])
mon_members = set([host for host in mon_initial_members])
for host in mon_initial_members:
mon_name = 'mon.%s' % host
LOG.info('processing monitor %s', mon_name)
sleeps = [20, 20, 15, 10, 10, 5]
tries = 5
rlogger = logging.getLogger(host)
rconn = get_connection(
host,
username=args.username,
logger=rlogger,
)
while tries:
status = mon_status_check(rconn, rlogger, host, args)
has_reached_quorum = status.get('state', '') in ['peon', 'leader']
if not has_reached_quorum:
LOG.warning('%s monitor is not yet in quorum, tries left: %s' %
(mon_name, tries))
tries -= 1
sleep_seconds = sleeps.pop()
LOG.warning('waiting %s seconds before retrying',
sleep_seconds)
time.sleep(sleep_seconds) # Magic number
else:
mon_in_quorum.add(host)
LOG.info('%s monitor has reached quorum!', mon_name)
break
rconn.exit()
if mon_in_quorum == mon_members:
LOG.info('all initial monitors are running and have formed quorum')
LOG.info('Running gatherkeys...')
gatherkeys.gatherkeys(args)
else:
LOG.error('Some monitors have still not reached quorum:')
for host in mon_members - mon_in_quorum:
LOG.error('%s', host)
raise SystemExit('cluster may not be in a healthy state')
def mon_create_initial(args):
cfg = conf.ceph.load(args)
cfg_initial_members = cfg.safe_get('global', 'mon_initial_members')
if cfg_initial_members is None:
raise RuntimeError('No `mon initial members` defined in config')
mon_initial_members = re.split(r'[,\s]+', cfg_initial_members)
# create them normally through mon_create
mon_create(args)
# make the sets to be able to compare late
mon_in_quorum = set([])
mon_members = set([host for host in mon_initial_members])
for host in mon_initial_members:
mon_name = 'mon.%s' % host
LOG.info('processing monitor %s', mon_name)
sleeps = [20, 20, 15, 10, 10, 5]
tries = 5
rlogger = logging.getLogger(host)
rconn = get_connection(host, username=args.username, logger=rlogger)
while tries:
status = mon_status_check(rconn, rlogger, host, args)
has_reached_quorum = status.get('state', '') in ['peon', 'leader']
if not has_reached_quorum:
LOG.warning('%s monitor is not yet in quorum, tries left: %s' %
(mon_name, tries))
tries -= 1
sleep_seconds = sleeps.pop()
LOG.warning('waiting %s seconds before retrying',
sleep_seconds)
time.sleep(sleep_seconds) # Magic number
else:
mon_in_quorum.add(host)
LOG.info('%s monitor has reached quorum!', mon_name)
break
rconn.exit()
if mon_in_quorum == mon_members:
LOG.info('all initial monitors are running and have formed quorum')
LOG.info('Running gatherkeys...')
gatherkeys.gatherkeys(args)
else:
LOG.error('Some monitors have still not reached quorum:')
for host in mon_members - mon_in_quorum:
LOG.error('%s', host)
raise SystemExit('cluster may not be in a healthy state')
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))
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 create(distro, logger, args, monitor_keyring):
hostname = remote_shortname(distro.sudo_conn.modules.socket)
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
distro.sudo_conn.close()
# TODO transition this once pushy is out
rconn = get_connection(hostname, logger)
process.run(
rconn,
[
service,
'ceph',
'start',
'mon.{hostname}'.format(hostname=hostname)
],
exit=True,
timeout=7,
)
def create(distro, logger, args, monitor_keyring):
hostname = remote_shortname(distro.sudo_conn.modules.socket)
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
distro.sudo_conn.close()
# TODO transition this once pushy is out
rconn = get_connection(hostname, logger)
process.run(
rconn,
[
service, 'ceph', '-c',
'/etc/ceph/{cluster}.conf'.format(cluster=args.cluster), 'start',
'mon.{hostname}'.format(hostname=hostname)
],
exit=True,
timeout=7,
)
def mon_create_initial(args):
mon_initial_members = get_mon_initial_members(args, error_on_empty=True)
# create them normally through mon_create
mon_create(args)
# make the sets to be able to compare late
mon_in_quorum = set([])
mon_members = set([host for host in mon_initial_members])
for host in mon_initial_members:
mon_name = "mon.%s" % host
LOG.info("processing monitor %s", mon_name)
sleeps = [20, 20, 15, 10, 10, 5]
tries = 5
rlogger = logging.getLogger(host)
rconn = get_connection(host, username=args.username, logger=rlogger)
while tries:
status = mon_status_check(rconn, rlogger, host, args)
has_reached_quorum = status.get("state", "") in ["peon", "leader"]
if not has_reached_quorum:
LOG.warning("%s monitor is not yet in quorum, tries left: %s" % (mon_name, tries))
tries -= 1
sleep_seconds = sleeps.pop()
LOG.warning("waiting %s seconds before retrying", sleep_seconds)
time.sleep(sleep_seconds) # Magic number
else:
mon_in_quorum.add(host)
LOG.info("%s monitor has reached quorum!", mon_name)
break
rconn.exit()
if mon_in_quorum == mon_members:
LOG.info("all initial monitors are running and have formed quorum")
LOG.info("Running gatherkeys...")
gatherkeys.gatherkeys(args)
else:
LOG.error("Some monitors have still not reached quorum:")
for host in mon_members - mon_in_quorum:
LOG.error("%s", host)
raise SystemExit("cluster may not be in a healthy state")
def create(distro, logger, args, monitor_keyring):
hostname = remote_shortname(distro.sudo_conn.modules.socket)
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
distro.sudo_conn.close()
# TODO transition this once pushy is out
rconn = get_connection(hostname, logger)
if distro.init == 'upstart': # Ubuntu uses upstart
process.run(
rconn,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=args.cluster),
'id={hostname}'.format(hostname=hostname),
],
exit=True,
timeout=7,
)
elif distro.init == 'sysvinit': # Debian uses sysvinit
process.run(
rconn,
[
service,
'ceph',
'-c',
'/etc/ceph/{cluster}.conf'.format(cluster=args.cluster),
'start',
'mon.{hostname}'.format(hostname=hostname)
],
exit=True,
timeout=7,
)
else:
raise RuntimeError('create cannot use init %s' % distro.init)
def create(distro, logger, args, monitor_keyring):
hostname = remote_shortname(distro.sudo_conn.modules.socket)
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
distro.sudo_conn.close()
# TODO transition this once pushy is out
rconn = get_connection(hostname, logger)
if distro.init == 'upstart': # Ubuntu uses upstart
process.run(
rconn,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=args.cluster),
'id={hostname}'.format(hostname=hostname),
],
exit=True,
timeout=7,
)
elif distro.init == 'sysvinit': # Debian uses sysvinit
process.run(
rconn,
[
service, 'ceph', '-c',
'/etc/ceph/{cluster}.conf'.format(cluster=args.cluster),
'start', 'mon.{hostname}'.format(hostname=hostname)
],
exit=True,
timeout=7,
)
else:
raise RuntimeError('create cannot use init %s' % distro.init)
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
