def create(distro, logger, args, monitor_keyring):
hostname = distro.sudo_conn.modules.socket.gethostname().split('.')[0]
common.mon_create(distro, logger, args, monitor_keyring, hostname)
if distro.init == 'upstart': # Ubuntu uses upstart
check_call(
distro.sudo_conn,
logger,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=args.cluster),
'id={hostname}'.format(hostname=hostname),
],
patch=False,
)
elif distro.init == 'sysvinit': # Debian uses sysvinit
service = common.which_service(distro.sudo_conn, logger)
check_call(
distro.sudo_conn,
logger,
[
service, 'ceph', 'start',
'mon.{hostname}'.format(hostname=hostname)
],
patch=False,
)
else:
raise RuntimeError('create cannot use init %s' % distro.init)
def create(distro, logger, args, monitor_keyring):
hostname = distro.sudo_conn.modules.socket.gethostname().split('.')[0]
common.mon_create(distro, logger, args, monitor_keyring, hostname)
if distro.init == 'upstart': # Ubuntu uses upstart
check_call(
distro.sudo_conn,
logger,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=args.cluster),
'id={hostname}'.format(hostname=hostname),
],
patch=False,
)
elif distro.init == 'sysvinit': # Debian uses sysvinit
service = common.which_service(distro.sudo_conn, logger)
check_call(
distro.sudo_conn,
logger,
[
service,
'ceph',
'start',
'mon.{hostname}'.format(hostname=hostname)
],
patch=False,
)
else:
raise RuntimeError('create cannot use init %s' % distro.init)
def create(distro, logger, args, monitor_keyring):
hostname = distro.sudo_conn.modules.socket.gethostname().split('.')[0]
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
check_call(
distro.sudo_conn,
logger,
[service, 'ceph', 'start', 'mon.{hostname}'.format(hostname=hostname)],
patch=False,
)
def create(distro, logger, args, monitor_keyring):
hostname = distro.sudo_conn.modules.socket.gethostname().split('.')[0]
common.mon_create(distro, logger, args, monitor_keyring, hostname)
service = common.which_service(distro.sudo_conn, logger)
check_call(
distro.sudo_conn,
logger,
[
service,
'ceph',
'start',
'mon.{hostname}'.format(hostname=hostname)
],
patch=False,
)
def yum(conn, logger, package, *a, **kw):
cmd = [
'yum',
'-y',
'-q',
'install',
package,
]
return wrappers.check_call(conn, logger, cmd, *a, **kw)
def install_epel(distro, logger):
"""
CentOS and Scientific need the EPEL repo, otherwise Ceph cannot be
installed.
"""
if distro.name.lower() in ['centos', 'scientific']:
logger.info('adding EPEL repository')
if float(distro.release) >= 6:
check_call(
distro.sudo_conn,
logger,
[
'wget',
'http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm'
],
stop_on_error=False,
)
pkg_managers.rpm(
distro.sudo_conn,
logger,
[
'--replacepkgs',
'epel-release-6*.rpm',
],
stop_on_error=False,
)
else:
check_call(
distro.sudo_conn,
logger,
[
'wget',
'wget http://dl.fedoraproject.org/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm'
],
stop_on_error=False,
)
pkg_managers.rpm(
distro.sudo_conn,
logger,
['--replacepkgs', 'epel-release-5*.rpm'],
stop_on_error=False,
)
def apt_update(conn, logger):
cmd = [
'apt-get',
'-q',
'update',
]
return wrappers.check_call(
conn,
logger,
cmd,
)
def apt(conn, logger, package, *a, **kw):
cmd = [
'env',
'DEBIAN_FRONTEND=noninteractive',
'apt-get',
'-q',
'install',
'--assume-yes',
package,
]
return wrappers.check_call(conn, logger, cmd, *a, **kw)
def apt_update(conn, logger):
cmd = [
'apt-get',
'-q',
'update',
]
return wrappers.check_call(
conn,
logger,
cmd,
)
def rpm(conn, logger, rpm_args=None, *a, **kw):
"""
A minimal front end for ``rpm`. Extra flags can be passed in via
``rpm_args`` as an iterable.
"""
rpm_args = rpm_args or []
cmd = [
'rpm',
'-Uvh',
]
cmd.extend(rpm_args)
return wrappers.check_call(conn, logger, cmd, *a, **kw)
def install_epel(distro, logger):
"""
CentOS and Scientific need the EPEL repo, otherwise Ceph cannot be
installed.
"""
if distro.name.lower() in ['centos', 'scientific']:
logger.info('adding EPEL repository')
if float(distro.release) >= 6:
check_call(
distro.sudo_conn,
logger,
['wget', 'http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm'],
stop_on_error=False,
)
pkg_managers.rpm(
distro.sudo_conn,
logger,
[
'--replacepkgs',
'epel-release-6*.rpm',
],
stop_on_error=False,
)
else:
check_call(
distro.sudo_conn,
logger,
['wget', 'wget http://dl.fedoraproject.org/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm'],
stop_on_error=False,
)
pkg_managers.rpm(
distro.sudo_conn,
logger,
[
'--replacepkgs',
'epel-release-5*.rpm'
],
stop_on_error=False,
)
def install(distro, logger, version_kind, version, adjust_repos):
release = distro.release
machine = distro.sudo_conn.modules.platform.machine()
# Get EPEL installed before we continue:
if adjust_repos:
install_epel(distro, logger)
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
if adjust_repos:
check_call(
distro.sudo_conn,
logger,
['su -c \'rpm --import "https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc"\''.format(key=key),],
shell=True)
if version_kind == 'stable':
url = 'http://ceph.com/rpm-{version}/el6/'.format(
version=version,
)
elif version_kind == 'testing':
url = 'http://ceph.com/rpm-testing/'
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-rpm-centos{release}-{machine}-basic/ref/{version}/'.format(
release=release.split(".",1)[0],
machine=machine,
version=version,
)
check_call(
distro.sudo_conn,
logger,
[
'rpm',
'-Uvh',
'--replacepkgs',
'{url}noarch/ceph-release-1-0.el6.noarch.rpm'.format(url=url),
],
)
check_call(
distro.sudo_conn,
logger,
[
'yum',
'-y',
'-q',
'install',
'ceph',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def yum(conn, logger, package, *a, **kw):
cmd = [
'yum',
'-y',
'-q',
'install',
package,
]
return wrappers.check_call(
conn,
logger,
cmd,
*a,
**kw
)
def apt(conn, logger, package, *a, **kw):
cmd = [
'env',
'DEBIAN_FRONTEND=noninteractive',
'apt-get',
'-q',
'install',
'--assume-yes',
package,
]
return wrappers.check_call(
conn,
logger,
cmd,
*a,
**kw
)
def rpm(conn, logger, rpm_args=None, *a, **kw):
"""
A minimal front end for ``rpm`. Extra flags can be passed in via
``rpm_args`` as an iterable.
"""
rpm_args = rpm_args or []
cmd = [
'rpm',
'-Uvh',
]
cmd.extend(rpm_args)
return wrappers.check_call(
conn,
logger,
cmd,
*a,
**kw
)
def install(distro, logger, version_kind, version):
codename = distro.codename
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
# Make sure ca-certificates is installed
check_call(distro.sudo_conn, logger, [
'env',
'DEBIAN_FRONTEND=noninteractive',
'apt-get',
'-q',
'install',
'--assume-yes',
'ca-certificates',
])
check_call(
distro.sudo_conn,
logger,
[
'wget -q -O- \'https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc\' | apt-key add -'
.format(key=key)
],
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/debian-{version}/'.format(version=version, )
elif version_kind == 'testing':
url = 'http://ceph.com/debian-testing/'
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-deb-{codename}-{machine}-basic/ref/{version}'.format(
codename=codename,
machine=machine,
version=version,
)
else:
raise RuntimeError('Unknown version kind: %r' % version_kind)
def write_sources_list(url, codename):
"""add ceph deb repo to sources.list"""
with file('/etc/apt/sources.list.d/ceph.list', 'w') as f:
f.write('deb {url} {codename} main\n'.format(
url=url,
codename=codename,
))
with remote(distro.sudo_conn, logger, write_sources_list) as remote_func:
remote_func(url, codename)
check_call(
distro.sudo_conn,
logger,
['apt-get', '-q', 'update'],
)
# TODO this does not downgrade -- should it?
check_call(
distro.sudo_conn,
logger,
[
'env',
'DEBIAN_FRONTEND=noninteractive',
'DEBIAN_PRIORITY=critical',
'apt-get',
'-q',
'-o',
'Dpkg::Options::=--force-confnew',
'install',
'--no-install-recommends',
'--assume-yes',
'--',
'ceph',
'ceph-mds',
'ceph-common',
'ceph-fs-common',
# ceph only recommends gdisk, make sure we actually have
# it; only really needed for osds, but minimal collateral
'gdisk',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def install(distro, logger, version_kind, version):
release = distro.release
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
check_call(
distro.sudo_conn,
logger,
args='su -c \'rpm --import "https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc"\''.format(key=key),
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/rpm-{version}/fc{release}/'.format(
version=version,
release=release,
)
elif version_kind == 'testing':
url = 'http://ceph.com/rpm-testing/fc{release}'.format(
release=release,
)
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-rpm-fc{release}-{machine}-basic/ref/{version}/'.format(
release=release.split(".", 1)[0],
machine=machine,
version=version,
)
check_call(
distro.sudo_conn,
logger,
args=[
'rpm',
'-Uvh',
'--replacepkgs',
'--force',
'--quiet',
'{url}noarch/ceph-release-1-0.fc{release}.noarch.rpm'.format(
url=url,
release=release,
),
]
)
check_call(
distro.sudo_conn,
logger,
args=[
'yum',
'-y',
'-q',
'install',
'ceph',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def install(distro, logger, version_kind, version, adjust_repos):
release = distro.release
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
if distro.codename == 'Mantis':
distro = 'opensuse12'
else:
distro = 'sles-11sp2'
if adjust_repos:
check_call(
distro.sudo_conn,
logger,
['su -c \'rpm --import "https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc"\''.format(key=key)],
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/rpm-{version}/{distro}/'.format(
version=version,
distro=distro,
)
elif version_kind == 'testing':
url = 'http://ceph.com/rpm-testing/{distro}'.format(distro=distro)
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-rpm-{distro}{release}-{machine}-basic/ref/{version}/'.format(
distro=distro,
release=release.split(".", 1)[0],
machine=machine,
version=version,
)
check_call(
distro.sudo_conn,
logger,
[
'rpm',
'-Uvh',
'--replacepkgs',
'--force',
'--quiet',
'{url}noarch/ceph-release-1-0.noarch.rpm'.format(
url=url,
),
]
)
check_call(
distro.sudo_conn,
logger,
[
'zypper',
'--non-interactive',
'--quiet',
'install',
'ceph',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def install(distro, logger, version_kind, version):
release = distro.release
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
check_call(
distro.sudo_conn,
logger,
args=
'su -c \'rpm --import "https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc"\''
.format(key=key),
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/rpm-{version}/fc{release}/'.format(
version=version,
release=release,
)
elif version_kind == 'testing':
url = 'http://ceph.com/rpm-testing/fc{release}'.format(
release=release, )
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-rpm-fc{release}-{machine}-basic/ref/{version}/'.format(
release=release.split(".", 1)[0],
machine=machine,
version=version,
)
check_call(
distro.sudo_conn,
logger,
args=[
'rpm',
'-Uvh',
'--replacepkgs',
'--force',
'--quiet',
'{url}noarch/ceph-release-1-0.fc{release}.noarch.rpm'.format(
url=url,
release=release,
),
])
check_call(
distro.sudo_conn,
logger,
args=[
'yum',
'-y',
'-q',
'install',
'ceph',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def install(distro, logger, version_kind, version, adjust_repos):
release = distro.release
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
if distro.codename == 'Mantis':
distro = 'opensuse12'
else:
distro = 'sles-11sp2'
if adjust_repos:
check_call(
distro.sudo_conn,
logger,
[
'su -c \'rpm --import "https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc"\''
.format(key=key)
],
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/rpm-{version}/{distro}/'.format(
version=version,
distro=distro,
)
elif version_kind == 'testing':
url = 'http://ceph.com/rpm-testing/{distro}'.format(distro=distro)
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-rpm-{distro}{release}-{machine}-basic/ref/{version}/'.format(
distro=distro,
release=release.split(".", 1)[0],
machine=machine,
version=version,
)
check_call(distro.sudo_conn, logger, [
'rpm',
'-Uvh',
'--replacepkgs',
'--force',
'--quiet',
'{url}noarch/ceph-release-1-0.noarch.rpm'.format(url=url, ),
])
check_call(
distro.sudo_conn,
logger,
[
'zypper',
'--non-interactive',
'--quiet',
'install',
'ceph',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def ceph_version(conn, logger):
"""
Log the remote ceph-version by calling `ceph --version`
"""
return check_call(conn, logger, ['ceph', '--version'])
def mon_create(distro, logger, args, monitor_keyring, hostname):
logger.debug('remote hostname: %s' % hostname)
path = paths.mon.path(args.cluster, hostname)
done_path = paths.mon.done(args.cluster, hostname)
init_path = paths.mon.init(args.cluster, hostname, distro.init)
configuration = conf.load(args)
conf_data = StringIO()
configuration.write(conf_data)
with remote(distro.sudo_conn, logger, conf.write_conf) as remote_func:
remote_func(args.cluster, conf_data.getvalue(), overwrite=args.overwrite_conf)
if not distro.sudo_conn.modules.os.path.exists(path):
logger.info('creating path: %s' % path)
distro.sudo_conn.modules.os.makedirs(path)
logger.debug('checking for done path: %s' % done_path)
if not distro.sudo_conn.modules.os.path.exists(done_path):
logger.debug('done path does not exist: %s' % done_path)
if not distro.sudo_conn.modules.os.path.exists(paths.mon.constants.tmp_path):
logger.info('creating tmp path: %s' % paths.mon.constants.tmp_path)
distro.sudo_conn.modules.os.makedirs(paths.mon.constants.tmp_path)
keyring = paths.mon.keyring(args.cluster, hostname)
def write_monitor_keyring(keyring, monitor_keyring):
"""create the monitor keyring file"""
with file(keyring, 'w') as f:
f.write(monitor_keyring)
logger.info('creating keyring file: %s' % keyring)
with remote(distro.sudo_conn, logger, write_monitor_keyring) as remote_func:
remote_func(keyring, monitor_keyring)
check_call(
distro.sudo_conn,
logger,
[
'ceph-mon',
'--cluster', args.cluster,
'--mkfs',
'-i', hostname,
'--keyring', keyring,
],
)
logger.info('unlinking keyring file %s' % keyring)
distro.sudo_conn.modules.os.unlink(keyring)
def create_done_path(done_path):
"""create a done file to avoid re-doing the mon deployment"""
with file(done_path, 'w'):
pass
with remote(distro.sudo_conn, logger, create_done_path) as remote_func:
remote_func(done_path)
def create_init_path(init_path):
"""create the init path if it does not exist"""
import os
if not os.path.exists(init_path):
with file(init_path, 'w'):
pass
with remote(distro.sudo_conn, logger, create_init_path) as remote_func:
remote_func(init_path)
def ceph_version(conn, logger):
"""
Log the remote ceph-version by calling `ceph --version`
"""
return check_call(conn, logger, ['ceph', '--version'])
def install(distro, logger, version_kind, version, adjust_repos):
codename = distro.codename
machine = distro.sudo_conn.modules.platform.machine()
if version_kind in ['stable', 'testing']:
key = 'release'
else:
key = 'autobuild'
# Make sure ca-certificates is installed
check_call(
distro.sudo_conn,
logger,
[
'env',
'DEBIAN_FRONTEND=noninteractive',
'apt-get',
'-q',
'install',
'--assume-yes',
'ca-certificates',
]
)
if adjust_repos:
check_call(
distro.sudo_conn,
logger,
['wget -q -O- \'https://ceph.com/git/?p=ceph.git;a=blob_plain;f=keys/{key}.asc\' | apt-key add -'.format(key=key)],
shell=True,
)
if version_kind == 'stable':
url = 'http://ceph.com/debian-{version}/'.format(
version=version,
)
elif version_kind == 'testing':
url = 'http://ceph.com/debian-testing/'
elif version_kind == 'dev':
url = 'http://gitbuilder.ceph.com/ceph-deb-{codename}-{machine}-basic/ref/{version}'.format(
codename=codename,
machine=machine,
version=version,
)
else:
raise RuntimeError('Unknown version kind: %r' % version_kind)
def write_sources_list(url, codename):
"""add ceph deb repo to sources.list"""
with file('/etc/apt/sources.list.d/ceph.list', 'w') as f:
f.write('deb {url} {codename} main\n'.format(
url=url,
codename=codename,
))
with remote(distro.sudo_conn, logger, write_sources_list) as remote_func:
remote_func(url, codename)
check_call(
distro.sudo_conn,
logger,
['apt-get', '-q', 'update'],
)
# TODO this does not downgrade -- should it?
check_call(
distro.sudo_conn,
logger,
[
'env',
'DEBIAN_FRONTEND=noninteractive',
'DEBIAN_PRIORITY=critical',
'apt-get',
'-q',
'-o', 'Dpkg::Options::=--force-confnew',
'--no-install-recommends',
'--assume-yes',
'install',
'--',
'ceph',
'ceph-mds',
'ceph-common',
'ceph-fs-common',
# ceph only recommends gdisk, make sure we actually have
# it; only really needed for osds, but minimal collateral
'gdisk',
],
)
# Check the ceph version
common.ceph_version(distro.sudo_conn, logger)
def mon_create(distro, logger, args, monitor_keyring, hostname):
logger.debug('remote hostname: %s' % hostname)
path = paths.mon.path(args.cluster, hostname)
done_path = paths.mon.done(args.cluster, hostname)
init_path = paths.mon.init(args.cluster, hostname, distro.init)
configuration = conf.load(args)
conf_data = StringIO()
configuration.write(conf_data)
with remote(distro.sudo_conn, logger, conf.write_conf) as remote_func:
remote_func(args.cluster,
conf_data.getvalue(),
overwrite=args.overwrite_conf)
if not distro.sudo_conn.modules.os.path.exists(path):
logger.info('creating path: %s' % path)
distro.sudo_conn.modules.os.makedirs(path)
logger.debug('checking for done path: %s' % done_path)
if not distro.sudo_conn.modules.os.path.exists(done_path):
logger.debug('done path does not exist: %s' % done_path)
if not distro.sudo_conn.modules.os.path.exists(
paths.mon.constants.tmp_path):
logger.info('creating tmp path: %s' % paths.mon.constants.tmp_path)
distro.sudo_conn.modules.os.makedirs(paths.mon.constants.tmp_path)
keyring = paths.mon.keyring(args.cluster, hostname)
def write_monitor_keyring(keyring, monitor_keyring):
"""create the monitor keyring file"""
with file(keyring, 'w') as f:
f.write(monitor_keyring)
logger.info('creating keyring file: %s' % keyring)
with remote(distro.sudo_conn, logger,
write_monitor_keyring) as remote_func:
remote_func(keyring, monitor_keyring)
check_call(
distro.sudo_conn,
logger,
[
'ceph-mon',
'--cluster',
args.cluster,
'--mkfs',
'-i',
hostname,
'--keyring',
keyring,
],
)
logger.info('unlinking keyring file %s' % keyring)
distro.sudo_conn.modules.os.unlink(keyring)
def create_done_path(done_path):
"""create a done file to avoid re-doing the mon deployment"""
with file(done_path, 'w'):
pass
with remote(distro.sudo_conn, logger, create_done_path) as remote_func:
remote_func(done_path)
def create_init_path(init_path):
"""create the init path if it does not exist"""
import os
if not os.path.exists(init_path):
with file(init_path, 'w'):
pass
with remote(distro.sudo_conn, logger, create_init_path) as remote_func:
remote_func(init_path)
