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 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