def _inspect_ceph_statedir(path):
"""
Helper function that collects /var/lib/ceph information from all minions.
Returns a dictionary of Path objects keyed on minion id.
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
# A container of Path's keyed on minion id.
statedirs = {}
for minion, path_info in local.cmd(search, 'fs.inspect_path',
["path={}".format(path)],
expr_form='compound').iteritems():
statedirs[minion] = Path(path, path_info['attrs'], path_info['exists'],
path_info['type'],
Device(path_info['dev_info']['dev'],
path_info['dev_info']['part_dev'],
path_info['dev_info']['type'],
path_info['dev_info']['uuid'],
path_info['dev_info']['fstype']),
Mount(path_info['mount_info']['mountpoint'],
path_info['mount_info']['opts'])) if path_info['ret'] else None
return statedirs
def discovery(cluster=None, printer=None, **kwargs):
"""
Check that the pillar for each cluster meets the requirements to install
a Ceph cluster.
"""
if not cluster:
usage(func='discovery')
exit(1)
local = salt.client.LocalClient()
# Restrict search to this cluster
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
if 'cluster' in __pillar__:
if __pillar__['cluster']:
# pylint: disable=redefined-variable-type
# Salt accepts either list or string as target
search = "I@cluster:{}".format(cluster)
pillar_data = local.cmd(search, 'pillar.items', [], expr_form="compound")
printer = get_printer(**kwargs)
valid = Validate(cluster, data=pillar_data, printer=printer)
valid.deepsea_minions(target)
valid.lint_yaml_files()
if not valid.in_dev_env:
valid.profiles_populated()
valid.report()
if valid.errors:
return False
return True
def __init__(self, settings, writer, **kwargs):
"""
Track cluster names, set minions to actively responding minions
Allow overriding of default cluster
"""
self.root_dir = settings.root_dir
if 'cluster' in kwargs:
self.names = kwargs['cluster']
else:
self.names = ['ceph']
self.writer = writer
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
self.minions = local.cmd(search,
'grains.get', ['id'],
expr_form="compound")
_rgws = local.cmd(search,
'pillar.get', ['rgw_configurations'],
expr_form="compound")
for node in _rgws.keys():
self.rgw_configurations = _rgws[node]
# Just need first
break
def ceph_version(self):
"""
Scan all minions for ceph versions in their repos.
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
contents = local.cmd(search, 'pkg.latest_version', ['ceph'], expr_form="compound")
for minion, version in contents.items():
if not version:
info = local.cmd(minion, 'pkg.info_installed', ['ceph'])
if info and 'version' in info[minion]['ceph']:
version = info[minion]['ceph']['version']
else:
self.errors.setdefault('ceph_version', []).append(
"No Ceph version is available for installation in {}".format(minion))
continue
colon_idx = version.find(':')
if colon_idx != -1:
version = version[colon_idx+1:]
dash_idx = version.rfind('-')
if dash_idx != -1:
version = version[:dash_idx]
if version < JEWEL_VERSION:
self.errors.setdefault('ceph_version', []).append(
"The Ceph version available in {} is older than 'jewel' (10.2)"
.format(minion))
self._set_pass_status('ceph_version')
def ceph_version(self):
"""
Scan all minions for ceph versions in their repos.
"""
JEWEL_VERSION = "10.2"
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
contents = local.cmd(search,
'cmd.shell', ['/usr/bin/zypper info ceph'],
expr_form="compound")
for minion in contents.keys():
m = re.search(r'Version: (\S+)', contents[minion])
# Skip minions with no ceph repo
if m:
version = m.group(1)
# String comparison works for now
if version < JEWEL_VERSION:
msg = "ceph version {} on minion {}".format(
version, minion)
self.errors.setdefault('ceph_version', []).append(msg)
self._set_pass_status('ceph_version')
def _get_existing_cluster_network(addrs, public_network=None):
"""
Based on the addrs dictionary { minion: [ ipaddress ] }, this function
returns an address consisting of network prefix followed by the cidr
prefix (ie. 10.0.0.0/24), or None.
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
# Stores the derived network addresses (in CIDR notation) of all addresses contained in addrs.
minion_networks = []
# The network address (in CIDR notation) that we return after collapsing minion_networks,
# or None.
network = None
# Grab network interfaces from salt.
minion_network_interfaces = local.cmd(search,
"network.interfaces", [],
expr_form="compound")
# Remove lo.
for entry in minion_network_interfaces:
try:
del (minion_network_interfaces[entry]["lo"])
except:
pass
for minion, ipaddr in addrs.items():
# Only continue if ipaddr is present.
for i in ipaddr:
for intf, data in minion_network_interfaces[minion].items():
if "inet" in data:
for inet_data in data["inet"]:
if i == "0.0.0.0":
# If running on 0.0.0.0, assume we can use public_network
ip = ipaddress.ip_interface(
u"{}".format(public_network)
) if public_network else ipaddress.ip_interface(
u"{}/{}".format(i, inet_data["netmask"]))
minion_networks.append(str(ip.network))
elif inet_data["address"] == i:
ip = ipaddress.ip_interface(u"{}/{}".format(
inet_data["address"], inet_data["netmask"]))
minion_networks.append(str(ip.network))
# Check for consistency across all entries.
if len(set(minion_networks)) == 1:
# We have equal entries.
network = minion_networks[0]
else:
# We have multiple possible networks. This is liable to happen with OSDs
# when there is a private cluster network. Let's try to remove the public
# network.
minion_networks = [n for n in minion_networks if n != public_network]
network = minion_networks[0] if len(
set(minion_networks)) == 1 else None
return network
def __init__(self, local):
"""
Query the cluster assignment and remove unassigned
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
self.minions = local.cmd(search, 'pillar.get', ['cluster'])
self.names = dict(self._clusters())
if 'unassigned' in self.names:
self.names.pop('unassigned')
def __init__(self, settings, cluster, servers, writer):
"""
Initialize role secrets, track parameters
"""
self.cluster = cluster
self.servers = servers
self.writer = writer
self.root_dir = settings.root_dir
target = deepsea_minions.DeepseaMinions()
self.search = target.deepsea_minions
self.networks = self._networks(self.servers)
self.public_networks, self.cluster_networks = self.public_cluster(
self.networks)
self.available_roles = ['storage']
def saltapi(**kwargs):
"""
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
pillar_data = local.cmd(search, 'pillar.items', [], expr_form="compound")
printer = get_printer(**kwargs)
v = Validate("salt-api", pillar_data, [], printer)
v.saltapi()
v.report()
if v.errors:
return False
return True
def deploy(**kwargs):
"""
Verify that Stage 4, Services can succeed.
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
pillar_data = local.cmd(search, 'pillar.items', [], expr_form="compound")
grains_data = local.cmd(search, 'grains.items', [], expr_form="compound")
printer = get_printer(**kwargs)
valid = Validate("deploy", pillar_data, grains_data, printer)
valid.openattic()
valid.report()
if valid.errors:
return False
return True
def setup(**kwargs):
"""
Check that initial files prior to any stage are correct
"""
target = deepsea_minions.DeepseaMinions()
search = target.deepsea_minions
local = salt.client.LocalClient()
pillar_data = local.cmd(search, 'pillar.items', [], expr_form="compound")
printer = get_printer(**kwargs)
valid = Validate("setup", pillar_data, [], printer)
valid.deepsea_minions(target)
valid.master_minion()
valid.ceph_version()
valid.report()
if valid.errors:
return False
return True
treated to be equivalent with db taking precedence.
name=default - Name of the storage profile and thus location of the
resulting files.
format=bluestore - The OSDs underlying storage format. Legal values are
bluestore and filestore.
encryption='' - Set to dmcrypt to encrypt OSD. Leave empty (the default)
for non-encrypted OSDs.
journal-size=5g
db-size=500m
wal-size=500m - Sizes for journal/db/wal partitions respectively. Specify a
number with a unit suffix. Unit suffix' as accepted by
sgdisk can be used, i.e. kibibytes (K), mebibytes (M),
gibibytes (G), tebibytes (T), or pebibytes (P).
'''
TARGET = deepsea_minions.DeepseaMinions()
STD_ARGS = {
'leftovers': False,
'standalone': False,
'nvme-ssd-spinner': False,
'nvme-ssd': False,
'nvme-spinner': False,
'ssd-spinner': False,
'ratio': 5,
'db-ratio': 5,
'target': TARGET.deepsea_minions,
'data': 0,
'journal': 0,
'wal': 0,
'name': 'default',
def iperf(cluster=None, exclude=None, output=None, **kwargs):
"""
iperf server created from the each minions and then clients are created
base on the server's cpu count and request that number of other minions
as client to hit the server and report the total bendwidth.
CLI Example: (Before DeepSea with a cluster configuration)
.. code-block:: bash
sudo salt-run net.iperf
or you can run it with exclude
.. code-block:: bash
sudo salt-run net.iperf exclude="E@host*,host-osd-name*,192.168.1.1"
(After DeepSea with a cluster configuration)
.. code-block:: bash
sudo salt-run net.iperf cluster=ceph
To get all host iperf result
sudo salt-run net.iperf cluster=ceph output=full
"""
exclude_string = exclude_iplist = None
if exclude:
exclude_string, exclude_iplist = _exclude_filter(exclude)
addresses = []
local = salt.client.LocalClient()
# Salt targets can use list or string
# pylint: disable=redefined-variable-type
if cluster:
search = "I@cluster:{}".format(cluster)
if exclude_string:
search += " and not ( " + exclude_string + " )"
log.debug("iperf: search {} ".format(search))
public_networks = local.cmd(search,
'pillar.item', ['public_network'],
expr_form="compound")
log.debug("iperf: public_network {} ".format(public_networks))
cluster_networks = local.cmd(search,
'pillar.item', ['cluster_network'],
expr_form="compound")
log.debug("iperf: cluster_network {} ".format(cluster_networks))
total = local.cmd(search, 'grains.get', ['ipv4'], expr_form="compound")
log.debug("iperf: total grains.get {} ".format(total))
public_addresses = []
cluster_addresses = []
for host in sorted(total.iterkeys()):
if 'public_network' in public_networks[host]:
public_addresses.extend(
_address(total[host],
public_networks[host]['public_network']))
if 'cluster_network' in cluster_networks[host]:
cluster_addresses.extend(
_address(total[host],
cluster_networks[host]['cluster_network']))
log.debug("iperf: public_network {} ".format(public_addresses))
log.debug("iperf: cluster_network {} ".format(cluster_addresses))
result = {}
_create_server(public_addresses)
p_result = _create_client(public_addresses)
_create_server(cluster_addresses)
c_result = _create_client(cluster_addresses)
p_sort = _add_unit(
sorted(p_result.items(), key=operator.itemgetter(1), reverse=True))
c_sort = _add_unit(
sorted(c_result.items(), key=operator.itemgetter(1), reverse=True))
if output:
result.update({'Public Network': p_sort})
result.update({'Cluster Network': c_sort})
return result
else:
result.update({
'Public Network': {
"Slowest 2 hosts": p_sort[-2:],
"Fastest 2 hosts": p_sort[:2]
}
})
result.update({
'Cluster Network': {
"Slowest 2 hosts": c_sort[-2:],
"Fastest 2 hosts": c_sort[:2]
}
})
return result
else:
search = deepsea_minions.DeepseaMinions().deepsea_minions
if exclude_string:
search += " and not ( " + exclude_string + " )"
log.debug("ping: search {} ".format(search))
addresses = local.cmd(search,
'grains.get', ['ipv4'],
expr_form="compound")
addresses = _flatten(addresses.values())
# Lazy loopback removal - use ipaddress when adding IPv6
try:
if addresses:
addresses.remove('127.0.0.1')
if exclude_iplist:
for ex_ip in exclude_iplist:
log.debug("ping: removing {} ip ".format(ex_ip))
addresses.remove(ex_ip)
except ValueError:
log.debug("ping: remove {} ip doesn't exist".format(ex_ip))
_create_server(addresses)
result = _create_client(addresses)
sort_result = _add_unit(
sorted(result.items(), key=operator.itemgetter(1), reverse=True))
if output:
return sort_result
else:
return {
"Slowest 2 hosts": sort_result[-2:],
"Fastest 2 hosts": sort_result[:2]
}
def ping(cluster=None, exclude=None, ping_type=None, **kwargs):
"""
Ping all addresses from all addresses on all minions. If cluster is passed,
restrict addresses to public and cluster networks.
Note: Some optimizations could be done here in the multi module (such as
skipping the source and destination when they are the same). However, the
unoptimized version is taking ~2.5 seconds on 18 minions with 72 addresses
for success. Failures take between 6 to 12 seconds. Optimizations should
focus there.
TODO: Convert commented out print statements to log.debug
CLI Example: (Before DeepSea with a cluster configuration)
.. code-block:: bash
sudo salt-run net.ping
or you can run it with exclude
.. code-block:: bash
sudo salt-run net.ping exclude="E@host*,host-osd-name*,192.168.1.1"
(After DeepSea with a cluster configuration)
.. code-block:: bash
sudo salt-run net.ping cluster=ceph
sudo salt-run net.ping ceph
"""
exclude_string = exclude_iplist = None
if exclude:
exclude_string, exclude_iplist = _exclude_filter(exclude)
extra_kwargs = _skip_dunder(kwargs)
if _skip_dunder(kwargs):
print "Unsupported parameters:{}".format(" ,".join(
extra_kwargs.keys()))
text = re.sub(
re.compile("^ {12}", re.MULTILINE), "", '''
salt-run net.ping [cluster] [exclude]
Ping all addresses from all addresses on all minions.
If cluster is specified, restrict addresses to cluster networks.
If exclude is specified, remove matching addresses.
Detail read the Salt compound matchers.
All the excluded individual ip address interface will be removed,
instead of ping from, the ping to interface will be removed.
Examples:
salt-run net.ping
salt-run net.ping ceph
salt-run net.ping ceph [email protected]
salt-run net.ping cluster=ceph [email protected]
salt-run net.ping [email protected]
salt-run net.ping [email protected]/29
salt-run net.ping exclude="E@host*,host-osd-name*,192.168.1.1"
''')
print text
return ""
local = salt.client.LocalClient()
# pylint: disable=redefined-variable-type
if cluster:
search = "I@cluster:{}".format(cluster)
if exclude_string:
search += " and not ( " + exclude_string + " )"
log.debug("ping: search {} ".format(search))
networks = local.cmd(search,
'pillar.item',
['cluster_network', 'public_network'],
expr_form="compound")
total = local.cmd(search, 'grains.get', ['ipv4'], expr_form="compound")
addresses = []
for host in sorted(total.iterkeys()):
if 'cluster_network' in networks[host]:
addresses.extend(
_address(total[host], networks[host]['cluster_network']))
if 'public_network' in networks[host]:
addresses.extend(
_address(total[host], networks[host]['public_network']))
else:
search = deepsea_minions.DeepseaMinions().deepsea_minions
if exclude_string:
search += " and not ( " + exclude_string + " )"
log.debug("ping: search {} ".format(search))
addresses = local.cmd(search,
'grains.get', ['ipv4'],
expr_form="compound")
addresses = _flatten(addresses.values())
# Lazy loopback removal - use ipaddress when adding IPv6
try:
if addresses:
addresses.remove('127.0.0.1')
if exclude_iplist:
for ex_ip in exclude_iplist:
log.debug("ping: removing {} ip ".format(ex_ip))
addresses.remove(ex_ip)
except ValueError:
log.debug("ping: remove {} ip doesn't exist".format(ex_ip))
if ping_type is "jumbo":
results = local.cmd(search,
'multi.jumbo_ping',
addresses,
expr_form="compound")
else:
results = local.cmd(search,
'multi.ping',
addresses,
expr_form="compound")
_summarize(len(addresses), results)
return ""
def engulf_existing_cluster(**kwargs):
"""
Assuming proposals() has already been run to collect hardware profiles and
all possible role assignments and common configuration, this will generate
a policy.cfg with roles and assignments reflecting whatever cluster is
currently deployed. It will also suck in all the keyrings so that they're
present when the configure stage is run.
This assumes your cluster is named "ceph". If it's not, things will break.
"""
local = salt.client.LocalClient()
settings = Settings()
salt_writer = SaltWriter(**kwargs)
# Make sure deepsea_minions contains valid minions before proceeding with engulf.
minions = deepsea_minions.DeepseaMinions()
search = minions.deepsea_minions
validator = validate.Validate(
"ceph", local.cmd(search, 'pillar.items', [], expr_form="compound"),
[], validate.get_printer())
validator.deepsea_minions(minions)
if validator.errors:
validator.report()
return False
policy_cfg = []
# Check for firewall/apparmor.
if not ready.check("ceph", True, search):
return False
# First, hand apply select Stage 0 functions
local.cmd(search, "saltutil.sync_all", [], expr_form="compound")
local.cmd(search, "state.apply", ["ceph.mines"], expr_form="compound")
# Run proposals gathering directly.
proposals()
# Our imported hardware profile proposal path
imported_profile = "profile-import"
imported_profile_path = settings.root_dir + "/" + imported_profile
# Used later on to compute cluster and public networks.
mon_addrs = {}
osd_addrs = {}
ceph_conf = None
previous_minion = None
admin_minion = None
mon_minions = []
mgr_instances = []
mds_instances = []
rgw_instances = []
for minion, info in local.cmd(search,
"cephinspector.inspect", [],
expr_form="compound").items():
if type(info) is not dict:
print("cephinspector.inspect failed on %s: %s" % (minion, info))
return False
if info["ceph_conf"] is not None:
if ceph_conf is None:
ceph_conf = info["ceph_conf"]
else:
if info["ceph_conf"] != ceph_conf:
# TODO: what's the best way to report errors from a runner?
print("ceph.conf on %s doesn't match ceph.conf on %s" %
(minion, previous_minion))
return False
previous_minion = minion
is_admin = info["has_admin_keyring"]
if admin_minion is None and is_admin:
# We'll talk to this minion later to obtain keyrings
admin_minion = minion
is_master = local.cmd(minion,
"pillar.get", ["master_minion"],
expr_form="compound")[minion] == minion
if not info["running_services"].keys(
) and not is_admin and not is_master:
# No ceph services running, no admin key, not the master_minion,
# don't assign it to the cluster
continue
policy_cfg.append("cluster-ceph/cluster/" + minion + ".sls")
if is_master:
policy_cfg.append("role-master/cluster/" + minion + ".sls")
elif is_admin:
policy_cfg.append("role-admin/cluster/" + minion + ".sls")
if "ceph-mon" in info["running_services"].keys():
mon_minions.append(minion)
policy_cfg.append("role-mon/cluster/" + minion + ".sls")
policy_cfg.append("role-mon/stack/default/ceph/minions/" + minion +
".yml")
for minion, ipaddrs in local.cmd(
minion,
"cephinspector.get_minion_public_networks", [],
expr_form="compound").items():
mon_addrs[minion] = ipaddrs
if "ceph-osd" in info["running_services"].keys():
# Needs a storage profile assigned (which may be different
# than the proposals deepsea has come up with, depending on
# how things were deployed)
ceph_disks = local.cmd(minion,
"cephinspector.get_ceph_disks_yml", [],
expr_form="compound")
if not ceph_disks:
log.error("Failed to get list of Ceph OSD disks.")
return [False]
for minion, store in ceph_disks.items():
minion_yml_dir = imported_profile_path + "/stack/default/ceph/minions"
minion_yml_path = minion_yml_dir + "/" + minion + ".yml"
_create_dirs(minion_yml_dir, "")
salt_writer.write(minion_yml_path, store)
minion_sls_data = {"roles": ["storage"]}
minion_sls_dir = imported_profile_path + "/cluster"
minion_sls_path = minion_sls_dir + "/" + minion + ".sls"
_create_dirs(minion_sls_dir, "")
salt_writer.write(minion_sls_path, minion_sls_data)
policy_cfg.append(
minion_sls_path[minion_sls_path.find(imported_profile):])
policy_cfg.append(
minion_yml_path[minion_yml_path.find(imported_profile):])
for minion, ipaddrs in local.cmd(
minion,
"cephinspector.get_minion_cluster_networks", [],
expr_form="compound").items():
osd_addrs[minion] = ipaddrs
if "ceph-mgr" in info["running_services"].keys():
policy_cfg.append("role-mgr/cluster/" + minion + ".sls")
for i in info["running_services"]["ceph-mgr"]:
mgr_instances.append(i)
if "ceph-mds" in info["running_services"].keys():
policy_cfg.append("role-mds/cluster/" + minion + ".sls")
for i in info["running_services"]["ceph-mds"]:
mds_instances.append(i)
if "ceph-radosgw" in info["running_services"].keys():
policy_cfg.append("role-rgw/cluster/" + minion + ".sls")
for i in info["running_services"]["ceph-radosgw"]:
rgw_instances.append(i)
# TODO: what else to do for rgw? Do we need to do something to
# populate rgw_configurations in pillar data?
if not admin_minion:
print("No nodes found with ceph.client.admin.keyring")
return False
# TODO: this is really not very DRY...
admin_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring",
["key=client.admin"],
expr_form="compound")[admin_minion]
if not admin_keyring:
print("Could not obtain client.admin keyring")
return False
mon_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring", ["key=mon."],
expr_form="compound")[admin_minion]
if not mon_keyring:
print("Could not obtain mon keyring")
return False
osd_bootstrap_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring",
["key=client.bootstrap-osd"],
expr_form="compound")[admin_minion]
if not osd_bootstrap_keyring:
print("Could not obtain osd bootstrap keyring")
return False
# If there's no MGR instances, add MGR roles automatically to all the MONs
# (since Luminous, MGR is a requirement, so it seems reasonable to add this
# role automatically for imported clusters)
if not mgr_instances:
print("No MGRs detected, automatically assigning role-mgr to MONs")
for minion in mon_minions:
policy_cfg.append("role-mgr/cluster/" + minion + ".sls")
with open("/srv/salt/ceph/admin/cache/ceph.client.admin.keyring",
'w') as keyring:
keyring.write(admin_keyring)
with open("/srv/salt/ceph/mon/cache/mon.keyring", 'w') as keyring:
# following srv/salt/ceph/mon/files/keyring.j2, this includes both mon
# and admin keyrings
keyring.write(mon_keyring)
keyring.write(admin_keyring)
with open("/srv/salt/ceph/osd/cache/bootstrap.keyring", 'w') as keyring:
keyring.write(osd_bootstrap_keyring)
for i in mgr_instances:
mgr_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring", ["key=mgr." + i],
expr_form="compound")[admin_minion]
if not mgr_keyring:
print("Could not obtain mgr." + i + " keyring")
return False
with open("/srv/salt/ceph/mgr/cache/" + i + ".keyring",
'w') as keyring:
keyring.write(mgr_keyring)
for i in mds_instances:
mds_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring", ["key=mds." + i],
expr_form="compound")[admin_minion]
if not mds_keyring:
print("Could not obtain mds." + i + " keyring")
return False
with open("/srv/salt/ceph/mds/cache/" + i + ".keyring",
'w') as keyring:
keyring.write(mds_keyring)
for i in rgw_instances:
rgw_keyring = local.cmd(admin_minion,
"cephinspector.get_keyring",
["key=client." + i],
expr_form="compound")[admin_minion]
if not rgw_keyring:
print("Could not obtain client." + i + " keyring")
return False
with open("/srv/salt/ceph/rgw/cache/client." + i + ".keyring",
'w') as keyring:
keyring.write(rgw_keyring)
# Now policy_cfg reflects the current deployment, make it a bit legible...
policy_cfg.sort()
# ...but inject the unassigned line first so it takes precendence,
# along with the global config bits (because they're prettier early)...
policy_cfg = [
"cluster-unassigned/cluster/*.sls",
"config/stack/default/ceph/cluster.yml",
"config/stack/default/global.yml"
] + policy_cfg
# ...and write it out (this will fail with EPERM if someone's already
# created a policy.cfg as root, BTW)
with open("/srv/pillar/ceph/proposals/policy.cfg", 'w') as policy:
policy.write("\n".join(policy_cfg) + "\n")
# We've also got a ceph.conf to play with
cp = configparser.RawConfigParser()
# This little bit of natiness strips whitespace from all the lines, as
# Python's configparser interprets leading whitespace as a line continuation,
# whereas ceph itself is happy to have leading whitespace.
cp.readfp(
StringIO("\n".join([line.strip() for line in ceph_conf.split("\n")])))
if not cp.has_section("global"):
print("ceph.conf is missing [global] section")
return False
if not cp.has_option("global", "fsid"):
print("ceph.conf is missing fsid")
return False
if not _replace_fsid_with_existing_cluster(cp.get("global", "fsid")):
log.error(
"Failed to replace derived fsid with fsid of existing cluster.")
return [False]
p_net_dict = _replace_public_network_with_existing_cluster(mon_addrs)
if not p_net_dict['ret']:
log.error(
"Failed to replace derived public_network with public_network of existing cluster."
)
return [False]
c_net_dict = _replace_cluster_network_with_existing_cluster(
osd_addrs, p_net_dict['public_network'])
if not c_net_dict['ret']:
log.error(
"Failed to replace derived cluster_network with cluster_network of existing cluster."
)
return [False]
# write out the imported ceph.conf
with open("/srv/salt/ceph/configuration/files/ceph.conf.import",
'w') as conf:
conf.write(ceph_conf)
# ensure the imported config will be used
_replace_key_in_cluster_yml("configuration_init", "default-import")
return True
treated to be equivalent with db taking precedence.
name=default - Name of the storage profile and thus location of the
resulting files.
format=bluestore - The OSDs underlying storage format. Legal values are
bluestore and filestore.
encryption='' - Set to dmcrypt to encrypt OSD. Leave empty (the default)
for non-encrypted OSDs.
journal-size=5g
db-size=500m
wal-size=500m - Sizes for journal/db/wal partitions respectively. Specify a
number with a unit suffix. Unit suffix' as accepted by
sgdisk can be used, i.e. kibibytes (K), mebibytes (M),
gibibytes (G), tebibytes (T), or pebibytes (P).
'''
target = deepsea_minions.DeepseaMinions()
std_args = {
'leftovers': False,
'standalone': False,
'nvme-ssd-spinner': False,
'nvme-ssd': False,
'nvme-spinner': False,
'ssd-spinner': False,
'ratio': 5,
'db-ratio': 5,
'target': target.deepsea_minions,
'data': 0,
'journal': 0,
'wal': 0,
'name': 'default',
