id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 51
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
247,200 | aws/sagemaker-containers | src/sagemaker_containers/_encoders.py | decode | def decode(obj, content_type):
# type: (np.array or Iterable or int or float, str) -> np.array
"""Decode an object ton a one of the default content types to a numpy array.
Args:
obj (object): to be decoded.
content_type (str): content type to be used.
Returns:
np.array: decoded object.
"""
try:
decoder = _decoders_map[content_type]
return decoder(obj)
except KeyError:
raise _errors.UnsupportedFormatError(content_type) | python | def decode(obj, content_type):
# type: (np.array or Iterable or int or float, str) -> np.array
try:
decoder = _decoders_map[content_type]
return decoder(obj)
except KeyError:
raise _errors.UnsupportedFormatError(content_type) | [
"def",
"decode",
"(",
"obj",
",",
"content_type",
")",
":",
"# type: (np.array or Iterable or int or float, str) -> np.array",
"try",
":",
"decoder",
"=",
"_decoders_map",
"[",
"content_type",
"]",
"return",
"decoder",
"(",
"obj",
")",
"except",
"KeyError",
":",
"raise",
"_errors",
".",
"UnsupportedFormatError",
"(",
"content_type",
")"
] | Decode an object ton a one of the default content types to a numpy array.
Args:
obj (object): to be decoded.
content_type (str): content type to be used.
Returns:
np.array: decoded object. | [
"Decode",
"an",
"object",
"ton",
"a",
"one",
"of",
"the",
"default",
"content",
"types",
"to",
"a",
"numpy",
"array",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_encoders.py#L125-L140 |
247,201 | aws/sagemaker-containers | src/sagemaker_containers/_encoders.py | encode | def encode(array_like, content_type):
# type: (np.array or Iterable or int or float, str) -> np.array
"""Encode an array like object in a specific content_type to a numpy array.
To understand better what an array like object is see:
https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays
Args:
array_like (np.array or Iterable or int or float): to be converted to numpy.
content_type (str): content type to be used.
Returns:
(np.array): object converted as numpy array.
"""
try:
encoder = _encoders_map[content_type]
return encoder(array_like)
except KeyError:
raise _errors.UnsupportedFormatError(content_type) | python | def encode(array_like, content_type):
# type: (np.array or Iterable or int or float, str) -> np.array
try:
encoder = _encoders_map[content_type]
return encoder(array_like)
except KeyError:
raise _errors.UnsupportedFormatError(content_type) | [
"def",
"encode",
"(",
"array_like",
",",
"content_type",
")",
":",
"# type: (np.array or Iterable or int or float, str) -> np.array",
"try",
":",
"encoder",
"=",
"_encoders_map",
"[",
"content_type",
"]",
"return",
"encoder",
"(",
"array_like",
")",
"except",
"KeyError",
":",
"raise",
"_errors",
".",
"UnsupportedFormatError",
"(",
"content_type",
")"
] | Encode an array like object in a specific content_type to a numpy array.
To understand better what an array like object is see:
https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays
Args:
array_like (np.array or Iterable or int or float): to be converted to numpy.
content_type (str): content type to be used.
Returns:
(np.array): object converted as numpy array. | [
"Encode",
"an",
"array",
"like",
"object",
"in",
"a",
"specific",
"content_type",
"to",
"a",
"numpy",
"array",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_encoders.py#L143-L161 |
247,202 | aws/sagemaker-containers | src/sagemaker_containers/_files.py | tmpdir | def tmpdir(suffix='', prefix='tmp', dir=None): # type: (str, str, str) -> None
"""Create a temporary directory with a context manager. The file is deleted when the context exits.
The prefix, suffix, and dir arguments are the same as for mkstemp().
Args:
suffix (str): If suffix is specified, the file name will end with that suffix, otherwise there will be no
suffix.
prefix (str): If prefix is specified, the file name will begin with that prefix; otherwise,
a default prefix is used.
dir (str): If dir is specified, the file will be created in that directory; otherwise, a default directory is
used.
Returns:
str: path to the directory
"""
tmp = tempfile.mkdtemp(suffix=suffix, prefix=prefix, dir=dir)
yield tmp
shutil.rmtree(tmp) | python | def tmpdir(suffix='', prefix='tmp', dir=None): # type: (str, str, str) -> None
tmp = tempfile.mkdtemp(suffix=suffix, prefix=prefix, dir=dir)
yield tmp
shutil.rmtree(tmp) | [
"def",
"tmpdir",
"(",
"suffix",
"=",
"''",
",",
"prefix",
"=",
"'tmp'",
",",
"dir",
"=",
"None",
")",
":",
"# type: (str, str, str) -> None",
"tmp",
"=",
"tempfile",
".",
"mkdtemp",
"(",
"suffix",
"=",
"suffix",
",",
"prefix",
"=",
"prefix",
",",
"dir",
"=",
"dir",
")",
"yield",
"tmp",
"shutil",
".",
"rmtree",
"(",
"tmp",
")"
] | Create a temporary directory with a context manager. The file is deleted when the context exits.
The prefix, suffix, and dir arguments are the same as for mkstemp().
Args:
suffix (str): If suffix is specified, the file name will end with that suffix, otherwise there will be no
suffix.
prefix (str): If prefix is specified, the file name will begin with that prefix; otherwise,
a default prefix is used.
dir (str): If dir is specified, the file will be created in that directory; otherwise, a default directory is
used.
Returns:
str: path to the directory | [
"Create",
"a",
"temporary",
"directory",
"with",
"a",
"context",
"manager",
".",
"The",
"file",
"is",
"deleted",
"when",
"the",
"context",
"exits",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_files.py#L50-L67 |
247,203 | aws/sagemaker-containers | src/sagemaker_containers/_files.py | download_and_extract | def download_and_extract(uri, name, path): # type: (str, str, str) -> None
"""Download, prepare and install a compressed tar file from S3 or local directory as an entry point.
SageMaker Python SDK saves the user provided entry points as compressed tar files in S3
Args:
name (str): name of the entry point.
uri (str): the location of the entry point.
path (bool): The path where the script will be installed. It will not download and install the
if the path already has the user entry point.
"""
if not os.path.exists(path):
os.makedirs(path)
if not os.listdir(path):
with tmpdir() as tmp:
if uri.startswith('s3://'):
dst = os.path.join(tmp, 'tar_file')
s3_download(uri, dst)
with tarfile.open(name=dst, mode='r:gz') as t:
t.extractall(path=path)
elif os.path.isdir(uri):
if uri == path:
return
if os.path.exists(path):
shutil.rmtree(path)
shutil.move(uri, path)
else:
shutil.copy2(uri, os.path.join(path, name)) | python | def download_and_extract(uri, name, path): # type: (str, str, str) -> None
if not os.path.exists(path):
os.makedirs(path)
if not os.listdir(path):
with tmpdir() as tmp:
if uri.startswith('s3://'):
dst = os.path.join(tmp, 'tar_file')
s3_download(uri, dst)
with tarfile.open(name=dst, mode='r:gz') as t:
t.extractall(path=path)
elif os.path.isdir(uri):
if uri == path:
return
if os.path.exists(path):
shutil.rmtree(path)
shutil.move(uri, path)
else:
shutil.copy2(uri, os.path.join(path, name)) | [
"def",
"download_and_extract",
"(",
"uri",
",",
"name",
",",
"path",
")",
":",
"# type: (str, str, str) -> None",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
":",
"os",
".",
"makedirs",
"(",
"path",
")",
"if",
"not",
"os",
".",
"listdir",
"(",
"path",
")",
":",
"with",
"tmpdir",
"(",
")",
"as",
"tmp",
":",
"if",
"uri",
".",
"startswith",
"(",
"'s3://'",
")",
":",
"dst",
"=",
"os",
".",
"path",
".",
"join",
"(",
"tmp",
",",
"'tar_file'",
")",
"s3_download",
"(",
"uri",
",",
"dst",
")",
"with",
"tarfile",
".",
"open",
"(",
"name",
"=",
"dst",
",",
"mode",
"=",
"'r:gz'",
")",
"as",
"t",
":",
"t",
".",
"extractall",
"(",
"path",
"=",
"path",
")",
"elif",
"os",
".",
"path",
".",
"isdir",
"(",
"uri",
")",
":",
"if",
"uri",
"==",
"path",
":",
"return",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
":",
"shutil",
".",
"rmtree",
"(",
"path",
")",
"shutil",
".",
"move",
"(",
"uri",
",",
"path",
")",
"else",
":",
"shutil",
".",
"copy2",
"(",
"uri",
",",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"name",
")",
")"
] | Download, prepare and install a compressed tar file from S3 or local directory as an entry point.
SageMaker Python SDK saves the user provided entry points as compressed tar files in S3
Args:
name (str): name of the entry point.
uri (str): the location of the entry point.
path (bool): The path where the script will be installed. It will not download and install the
if the path already has the user entry point. | [
"Download",
"prepare",
"and",
"install",
"a",
"compressed",
"tar",
"file",
"from",
"S3",
"or",
"local",
"directory",
"as",
"an",
"entry",
"point",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_files.py#L108-L137 |
247,204 | aws/sagemaker-containers | src/sagemaker_containers/_files.py | s3_download | def s3_download(url, dst): # type: (str, str) -> None
"""Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved.
"""
url = parse.urlparse(url)
if url.scheme != 's3':
raise ValueError("Expecting 's3' scheme, got: %s in %s" % (url.scheme, url))
bucket, key = url.netloc, url.path.lstrip('/')
region = os.environ.get('AWS_REGION', os.environ.get(_params.REGION_NAME_ENV))
s3 = boto3.resource('s3', region_name=region)
s3.Bucket(bucket).download_file(key, dst) | python | def s3_download(url, dst): # type: (str, str) -> None
url = parse.urlparse(url)
if url.scheme != 's3':
raise ValueError("Expecting 's3' scheme, got: %s in %s" % (url.scheme, url))
bucket, key = url.netloc, url.path.lstrip('/')
region = os.environ.get('AWS_REGION', os.environ.get(_params.REGION_NAME_ENV))
s3 = boto3.resource('s3', region_name=region)
s3.Bucket(bucket).download_file(key, dst) | [
"def",
"s3_download",
"(",
"url",
",",
"dst",
")",
":",
"# type: (str, str) -> None",
"url",
"=",
"parse",
".",
"urlparse",
"(",
"url",
")",
"if",
"url",
".",
"scheme",
"!=",
"'s3'",
":",
"raise",
"ValueError",
"(",
"\"Expecting 's3' scheme, got: %s in %s\"",
"%",
"(",
"url",
".",
"scheme",
",",
"url",
")",
")",
"bucket",
",",
"key",
"=",
"url",
".",
"netloc",
",",
"url",
".",
"path",
".",
"lstrip",
"(",
"'/'",
")",
"region",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'AWS_REGION'",
",",
"os",
".",
"environ",
".",
"get",
"(",
"_params",
".",
"REGION_NAME_ENV",
")",
")",
"s3",
"=",
"boto3",
".",
"resource",
"(",
"'s3'",
",",
"region_name",
"=",
"region",
")",
"s3",
".",
"Bucket",
"(",
"bucket",
")",
".",
"download_file",
"(",
"key",
",",
"dst",
")"
] | Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved. | [
"Download",
"a",
"file",
"from",
"S3",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_files.py#L140-L157 |
247,205 | aws/sagemaker-containers | src/sagemaker_containers/_functions.py | matching_args | def matching_args(fn, dictionary): # type: (Callable, _mapping.Mapping) -> dict
"""Given a function fn and a dict dictionary, returns the function arguments that match the dict keys.
Example:
def train(channel_dirs, model_dir): pass
dictionary = {'channel_dirs': {}, 'model_dir': '/opt/ml/model', 'other_args': None}
args = functions.matching_args(train, dictionary) # {'channel_dirs': {}, 'model_dir': '/opt/ml/model'}
train(**args)
Args:
fn (function): a function
dictionary (dict): the dictionary with the keys
Returns:
(dict) a dictionary with only matching arguments.
"""
arg_spec = getargspec(fn)
if arg_spec.keywords:
return dictionary
return _mapping.split_by_criteria(dictionary, arg_spec.args).included | python | def matching_args(fn, dictionary): # type: (Callable, _mapping.Mapping) -> dict
arg_spec = getargspec(fn)
if arg_spec.keywords:
return dictionary
return _mapping.split_by_criteria(dictionary, arg_spec.args).included | [
"def",
"matching_args",
"(",
"fn",
",",
"dictionary",
")",
":",
"# type: (Callable, _mapping.Mapping) -> dict",
"arg_spec",
"=",
"getargspec",
"(",
"fn",
")",
"if",
"arg_spec",
".",
"keywords",
":",
"return",
"dictionary",
"return",
"_mapping",
".",
"split_by_criteria",
"(",
"dictionary",
",",
"arg_spec",
".",
"args",
")",
".",
"included"
] | Given a function fn and a dict dictionary, returns the function arguments that match the dict keys.
Example:
def train(channel_dirs, model_dir): pass
dictionary = {'channel_dirs': {}, 'model_dir': '/opt/ml/model', 'other_args': None}
args = functions.matching_args(train, dictionary) # {'channel_dirs': {}, 'model_dir': '/opt/ml/model'}
train(**args)
Args:
fn (function): a function
dictionary (dict): the dictionary with the keys
Returns:
(dict) a dictionary with only matching arguments. | [
"Given",
"a",
"function",
"fn",
"and",
"a",
"dict",
"dictionary",
"returns",
"the",
"function",
"arguments",
"that",
"match",
"the",
"dict",
"keys",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_functions.py#L24-L48 |
247,206 | aws/sagemaker-containers | src/sagemaker_containers/_functions.py | error_wrapper | def error_wrapper(fn, error_class): # type: (Callable or None, Exception) -> ...
"""Wraps function fn in a try catch block that re-raises error_class.
Args:
fn (function): function to wrapped
error_class (Exception): Error class to be re-raised
Returns:
(object): fn wrapped in a try catch.
"""
def wrapper(*args, **kwargs):
try:
return fn(*args, **kwargs)
except Exception as e:
six.reraise(error_class, error_class(e), sys.exc_info()[2])
return wrapper | python | def error_wrapper(fn, error_class): # type: (Callable or None, Exception) -> ...
def wrapper(*args, **kwargs):
try:
return fn(*args, **kwargs)
except Exception as e:
six.reraise(error_class, error_class(e), sys.exc_info()[2])
return wrapper | [
"def",
"error_wrapper",
"(",
"fn",
",",
"error_class",
")",
":",
"# type: (Callable or None, Exception) -> ...",
"def",
"wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"return",
"fn",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"Exception",
"as",
"e",
":",
"six",
".",
"reraise",
"(",
"error_class",
",",
"error_class",
"(",
"e",
")",
",",
"sys",
".",
"exc_info",
"(",
")",
"[",
"2",
"]",
")",
"return",
"wrapper"
] | Wraps function fn in a try catch block that re-raises error_class.
Args:
fn (function): function to wrapped
error_class (Exception): Error class to be re-raised
Returns:
(object): fn wrapped in a try catch. | [
"Wraps",
"function",
"fn",
"in",
"a",
"try",
"catch",
"block",
"that",
"re",
"-",
"raises",
"error_class",
"."
] | 0030f07abbaf22a55d986d97274d7a8d1aa1f10c | https://github.com/aws/sagemaker-containers/blob/0030f07abbaf22a55d986d97274d7a8d1aa1f10c/src/sagemaker_containers/_functions.py#L73-L89 |
247,207 | ceph/ceph-deploy | ceph_deploy/util/packages.py | ceph_is_installed | def ceph_is_installed(module):
"""
A helper callback to be executed after the connection is made to ensure
that Ceph is installed.
"""
ceph_package = Ceph(module.conn)
if not ceph_package.installed:
host = module.conn.hostname
raise RuntimeError(
'ceph needs to be installed in remote host: %s' % host
) | python | def ceph_is_installed(module):
ceph_package = Ceph(module.conn)
if not ceph_package.installed:
host = module.conn.hostname
raise RuntimeError(
'ceph needs to be installed in remote host: %s' % host
) | [
"def",
"ceph_is_installed",
"(",
"module",
")",
":",
"ceph_package",
"=",
"Ceph",
"(",
"module",
".",
"conn",
")",
"if",
"not",
"ceph_package",
".",
"installed",
":",
"host",
"=",
"module",
".",
"conn",
".",
"hostname",
"raise",
"RuntimeError",
"(",
"'ceph needs to be installed in remote host: %s'",
"%",
"host",
")"
] | A helper callback to be executed after the connection is made to ensure
that Ceph is installed. | [
"A",
"helper",
"callback",
"to",
"be",
"executed",
"after",
"the",
"connection",
"is",
"made",
"to",
"ensure",
"that",
"Ceph",
"is",
"installed",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/packages.py#L64-L74 |
247,208 | ceph/ceph-deploy | ceph_deploy/util/log.py | color_format | def color_format():
"""
Main entry point to get a colored formatter, it will use the
BASE_FORMAT by default and fall back to no colors if the system
does not support it
"""
str_format = BASE_COLOR_FORMAT if supports_color() else BASE_FORMAT
color_format = color_message(str_format)
return ColoredFormatter(color_format) | python | def color_format():
str_format = BASE_COLOR_FORMAT if supports_color() else BASE_FORMAT
color_format = color_message(str_format)
return ColoredFormatter(color_format) | [
"def",
"color_format",
"(",
")",
":",
"str_format",
"=",
"BASE_COLOR_FORMAT",
"if",
"supports_color",
"(",
")",
"else",
"BASE_FORMAT",
"color_format",
"=",
"color_message",
"(",
"str_format",
")",
"return",
"ColoredFormatter",
"(",
"color_format",
")"
] | Main entry point to get a colored formatter, it will use the
BASE_FORMAT by default and fall back to no colors if the system
does not support it | [
"Main",
"entry",
"point",
"to",
"get",
"a",
"colored",
"formatter",
"it",
"will",
"use",
"the",
"BASE_FORMAT",
"by",
"default",
"and",
"fall",
"back",
"to",
"no",
"colors",
"if",
"the",
"system",
"does",
"not",
"support",
"it"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/log.py#L59-L67 |
247,209 | ceph/ceph-deploy | ceph_deploy/mon.py | mon_status_check | def mon_status_check(conn, logger, hostname, args):
"""
A direct check for JSON output on the monitor status.
For newer versions of Ceph (dumpling and newer) a new mon_status command
was added ( `ceph daemon mon mon_status` ) and should be revisited if the
output changes as this check depends on that availability.
"""
asok_path = paths.mon.asok(args.cluster, hostname)
out, err, code = remoto.process.check(
conn,
[
'ceph',
'--cluster={cluster}'.format(cluster=args.cluster),
'--admin-daemon',
asok_path,
'mon_status',
],
)
for line in err:
logger.error(line)
try:
return json.loads(b''.join(out).decode('utf-8'))
except ValueError:
return {} | python | def mon_status_check(conn, logger, hostname, args):
asok_path = paths.mon.asok(args.cluster, hostname)
out, err, code = remoto.process.check(
conn,
[
'ceph',
'--cluster={cluster}'.format(cluster=args.cluster),
'--admin-daemon',
asok_path,
'mon_status',
],
)
for line in err:
logger.error(line)
try:
return json.loads(b''.join(out).decode('utf-8'))
except ValueError:
return {} | [
"def",
"mon_status_check",
"(",
"conn",
",",
"logger",
",",
"hostname",
",",
"args",
")",
":",
"asok_path",
"=",
"paths",
".",
"mon",
".",
"asok",
"(",
"args",
".",
"cluster",
",",
"hostname",
")",
"out",
",",
"err",
",",
"code",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"conn",
",",
"[",
"'ceph'",
",",
"'--cluster={cluster}'",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
")",
",",
"'--admin-daemon'",
",",
"asok_path",
",",
"'mon_status'",
",",
"]",
",",
")",
"for",
"line",
"in",
"err",
":",
"logger",
".",
"error",
"(",
"line",
")",
"try",
":",
"return",
"json",
".",
"loads",
"(",
"b''",
".",
"join",
"(",
"out",
")",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"except",
"ValueError",
":",
"return",
"{",
"}"
] | A direct check for JSON output on the monitor status.
For newer versions of Ceph (dumpling and newer) a new mon_status command
was added ( `ceph daemon mon mon_status` ) and should be revisited if the
output changes as this check depends on that availability. | [
"A",
"direct",
"check",
"for",
"JSON",
"output",
"on",
"the",
"monitor",
"status",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L21-L49 |
247,210 | ceph/ceph-deploy | ceph_deploy/mon.py | catch_mon_errors | def catch_mon_errors(conn, logger, hostname, cfg, args):
"""
Make sure we are able to catch up common mishaps with monitors
and use that state of a monitor to determine what is missing
and warn apropriately about it.
"""
monmap = mon_status_check(conn, logger, hostname, args).get('monmap', {})
mon_initial_members = get_mon_initial_members(args, _cfg=cfg)
public_addr = cfg.safe_get('global', 'public_addr')
public_network = cfg.safe_get('global', 'public_network')
mon_in_monmap = [
mon.get('name')
for mon in monmap.get('mons', [{}])
if mon.get('name') == hostname
]
if mon_initial_members is None or not hostname in mon_initial_members:
logger.warning('%s is not defined in `mon initial members`', hostname)
if not mon_in_monmap:
logger.warning('monitor %s does not exist in monmap', hostname)
if not public_addr and not public_network:
logger.warning('neither `public_addr` nor `public_network` keys are defined for monitors')
logger.warning('monitors may not be able to form quorum') | python | def catch_mon_errors(conn, logger, hostname, cfg, args):
monmap = mon_status_check(conn, logger, hostname, args).get('monmap', {})
mon_initial_members = get_mon_initial_members(args, _cfg=cfg)
public_addr = cfg.safe_get('global', 'public_addr')
public_network = cfg.safe_get('global', 'public_network')
mon_in_monmap = [
mon.get('name')
for mon in monmap.get('mons', [{}])
if mon.get('name') == hostname
]
if mon_initial_members is None or not hostname in mon_initial_members:
logger.warning('%s is not defined in `mon initial members`', hostname)
if not mon_in_monmap:
logger.warning('monitor %s does not exist in monmap', hostname)
if not public_addr and not public_network:
logger.warning('neither `public_addr` nor `public_network` keys are defined for monitors')
logger.warning('monitors may not be able to form quorum') | [
"def",
"catch_mon_errors",
"(",
"conn",
",",
"logger",
",",
"hostname",
",",
"cfg",
",",
"args",
")",
":",
"monmap",
"=",
"mon_status_check",
"(",
"conn",
",",
"logger",
",",
"hostname",
",",
"args",
")",
".",
"get",
"(",
"'monmap'",
",",
"{",
"}",
")",
"mon_initial_members",
"=",
"get_mon_initial_members",
"(",
"args",
",",
"_cfg",
"=",
"cfg",
")",
"public_addr",
"=",
"cfg",
".",
"safe_get",
"(",
"'global'",
",",
"'public_addr'",
")",
"public_network",
"=",
"cfg",
".",
"safe_get",
"(",
"'global'",
",",
"'public_network'",
")",
"mon_in_monmap",
"=",
"[",
"mon",
".",
"get",
"(",
"'name'",
")",
"for",
"mon",
"in",
"monmap",
".",
"get",
"(",
"'mons'",
",",
"[",
"{",
"}",
"]",
")",
"if",
"mon",
".",
"get",
"(",
"'name'",
")",
"==",
"hostname",
"]",
"if",
"mon_initial_members",
"is",
"None",
"or",
"not",
"hostname",
"in",
"mon_initial_members",
":",
"logger",
".",
"warning",
"(",
"'%s is not defined in `mon initial members`'",
",",
"hostname",
")",
"if",
"not",
"mon_in_monmap",
":",
"logger",
".",
"warning",
"(",
"'monitor %s does not exist in monmap'",
",",
"hostname",
")",
"if",
"not",
"public_addr",
"and",
"not",
"public_network",
":",
"logger",
".",
"warning",
"(",
"'neither `public_addr` nor `public_network` keys are defined for monitors'",
")",
"logger",
".",
"warning",
"(",
"'monitors may not be able to form quorum'",
")"
] | Make sure we are able to catch up common mishaps with monitors
and use that state of a monitor to determine what is missing
and warn apropriately about it. | [
"Make",
"sure",
"we",
"are",
"able",
"to",
"catch",
"up",
"common",
"mishaps",
"with",
"monitors",
"and",
"use",
"that",
"state",
"of",
"a",
"monitor",
"to",
"determine",
"what",
"is",
"missing",
"and",
"warn",
"apropriately",
"about",
"it",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L52-L73 |
247,211 | ceph/ceph-deploy | ceph_deploy/mon.py | mon_status | def mon_status(conn, logger, hostname, args, silent=False):
"""
run ``ceph daemon mon.`hostname` mon_status`` on the remote end and provide
not only the output, but be able to return a boolean status of what is
going on.
``False`` represents a monitor that is not doing OK even if it is up and
running, while ``True`` would mean the monitor is up and running correctly.
"""
mon = 'mon.%s' % hostname
try:
out = mon_status_check(conn, logger, hostname, args)
if not out:
logger.warning('monitor: %s, might not be running yet' % mon)
return False
if not silent:
logger.debug('*'*80)
logger.debug('status for monitor: %s' % mon)
for line in json.dumps(out, indent=2, sort_keys=True).split('\n'):
logger.debug(line)
logger.debug('*'*80)
if out['rank'] >= 0:
logger.info('monitor: %s is running' % mon)
return True
if out['rank'] == -1 and out['state']:
logger.info('monitor: %s is currently at the state of %s' % (mon, out['state']))
return True
logger.info('monitor: %s is not running' % mon)
return False
except RuntimeError:
logger.info('monitor: %s is not running' % mon)
return False | python | def mon_status(conn, logger, hostname, args, silent=False):
mon = 'mon.%s' % hostname
try:
out = mon_status_check(conn, logger, hostname, args)
if not out:
logger.warning('monitor: %s, might not be running yet' % mon)
return False
if not silent:
logger.debug('*'*80)
logger.debug('status for monitor: %s' % mon)
for line in json.dumps(out, indent=2, sort_keys=True).split('\n'):
logger.debug(line)
logger.debug('*'*80)
if out['rank'] >= 0:
logger.info('monitor: %s is running' % mon)
return True
if out['rank'] == -1 and out['state']:
logger.info('monitor: %s is currently at the state of %s' % (mon, out['state']))
return True
logger.info('monitor: %s is not running' % mon)
return False
except RuntimeError:
logger.info('monitor: %s is not running' % mon)
return False | [
"def",
"mon_status",
"(",
"conn",
",",
"logger",
",",
"hostname",
",",
"args",
",",
"silent",
"=",
"False",
")",
":",
"mon",
"=",
"'mon.%s'",
"%",
"hostname",
"try",
":",
"out",
"=",
"mon_status_check",
"(",
"conn",
",",
"logger",
",",
"hostname",
",",
"args",
")",
"if",
"not",
"out",
":",
"logger",
".",
"warning",
"(",
"'monitor: %s, might not be running yet'",
"%",
"mon",
")",
"return",
"False",
"if",
"not",
"silent",
":",
"logger",
".",
"debug",
"(",
"'*'",
"*",
"80",
")",
"logger",
".",
"debug",
"(",
"'status for monitor: %s'",
"%",
"mon",
")",
"for",
"line",
"in",
"json",
".",
"dumps",
"(",
"out",
",",
"indent",
"=",
"2",
",",
"sort_keys",
"=",
"True",
")",
".",
"split",
"(",
"'\\n'",
")",
":",
"logger",
".",
"debug",
"(",
"line",
")",
"logger",
".",
"debug",
"(",
"'*'",
"*",
"80",
")",
"if",
"out",
"[",
"'rank'",
"]",
">=",
"0",
":",
"logger",
".",
"info",
"(",
"'monitor: %s is running'",
"%",
"mon",
")",
"return",
"True",
"if",
"out",
"[",
"'rank'",
"]",
"==",
"-",
"1",
"and",
"out",
"[",
"'state'",
"]",
":",
"logger",
".",
"info",
"(",
"'monitor: %s is currently at the state of %s'",
"%",
"(",
"mon",
",",
"out",
"[",
"'state'",
"]",
")",
")",
"return",
"True",
"logger",
".",
"info",
"(",
"'monitor: %s is not running'",
"%",
"mon",
")",
"return",
"False",
"except",
"RuntimeError",
":",
"logger",
".",
"info",
"(",
"'monitor: %s is not running'",
"%",
"mon",
")",
"return",
"False"
] | run ``ceph daemon mon.`hostname` mon_status`` on the remote end and provide
not only the output, but be able to return a boolean status of what is
going on.
``False`` represents a monitor that is not doing OK even if it is up and
running, while ``True`` would mean the monitor is up and running correctly. | [
"run",
"ceph",
"daemon",
"mon",
".",
"hostname",
"mon_status",
"on",
"the",
"remote",
"end",
"and",
"provide",
"not",
"only",
"the",
"output",
"but",
"be",
"able",
"to",
"return",
"a",
"boolean",
"status",
"of",
"what",
"is",
"going",
"on",
".",
"False",
"represents",
"a",
"monitor",
"that",
"is",
"not",
"doing",
"OK",
"even",
"if",
"it",
"is",
"up",
"and",
"running",
"while",
"True",
"would",
"mean",
"the",
"monitor",
"is",
"up",
"and",
"running",
"correctly",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L76-L108 |
247,212 | ceph/ceph-deploy | ceph_deploy/mon.py | hostname_is_compatible | def hostname_is_compatible(conn, logger, provided_hostname):
"""
Make sure that the host that we are connecting to has the same value as the
`hostname` in the remote host, otherwise mons can fail not reaching quorum.
"""
logger.debug('determining if provided host has same hostname in remote')
remote_hostname = conn.remote_module.shortname()
if remote_hostname == provided_hostname:
return
logger.warning('*'*80)
logger.warning('provided hostname must match remote hostname')
logger.warning('provided hostname: %s' % provided_hostname)
logger.warning('remote hostname: %s' % remote_hostname)
logger.warning('monitors may not reach quorum and create-keys will not complete')
logger.warning('*'*80) | python | def hostname_is_compatible(conn, logger, provided_hostname):
logger.debug('determining if provided host has same hostname in remote')
remote_hostname = conn.remote_module.shortname()
if remote_hostname == provided_hostname:
return
logger.warning('*'*80)
logger.warning('provided hostname must match remote hostname')
logger.warning('provided hostname: %s' % provided_hostname)
logger.warning('remote hostname: %s' % remote_hostname)
logger.warning('monitors may not reach quorum and create-keys will not complete')
logger.warning('*'*80) | [
"def",
"hostname_is_compatible",
"(",
"conn",
",",
"logger",
",",
"provided_hostname",
")",
":",
"logger",
".",
"debug",
"(",
"'determining if provided host has same hostname in remote'",
")",
"remote_hostname",
"=",
"conn",
".",
"remote_module",
".",
"shortname",
"(",
")",
"if",
"remote_hostname",
"==",
"provided_hostname",
":",
"return",
"logger",
".",
"warning",
"(",
"'*'",
"*",
"80",
")",
"logger",
".",
"warning",
"(",
"'provided hostname must match remote hostname'",
")",
"logger",
".",
"warning",
"(",
"'provided hostname: %s'",
"%",
"provided_hostname",
")",
"logger",
".",
"warning",
"(",
"'remote hostname: %s'",
"%",
"remote_hostname",
")",
"logger",
".",
"warning",
"(",
"'monitors may not reach quorum and create-keys will not complete'",
")",
"logger",
".",
"warning",
"(",
"'*'",
"*",
"80",
")"
] | Make sure that the host that we are connecting to has the same value as the
`hostname` in the remote host, otherwise mons can fail not reaching quorum. | [
"Make",
"sure",
"that",
"the",
"host",
"that",
"we",
"are",
"connecting",
"to",
"has",
"the",
"same",
"value",
"as",
"the",
"hostname",
"in",
"the",
"remote",
"host",
"otherwise",
"mons",
"can",
"fail",
"not",
"reaching",
"quorum",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L290-L304 |
247,213 | ceph/ceph-deploy | ceph_deploy/mon.py | make | def make(parser):
"""
Ceph MON Daemon management
"""
parser.formatter_class = ToggleRawTextHelpFormatter
mon_parser = parser.add_subparsers(dest='subcommand')
mon_parser.required = True
mon_add = mon_parser.add_parser(
'add',
help=('R|Add a monitor to an existing cluster:\n'
'\tceph-deploy mon add node1\n'
'Or:\n'
'\tceph-deploy mon add --address 192.168.1.10 node1\n'
'If the section for the monitor exists and defines a `mon addr` that\n'
'will be used, otherwise it will fallback by resolving the hostname to an\n'
'IP. If `--address` is used it will override all other options.')
)
mon_add.add_argument(
'--address',
nargs='?',
)
mon_add.add_argument(
'mon',
nargs=1,
)
mon_create = mon_parser.add_parser(
'create',
help=('R|Deploy monitors by specifying them like:\n'
'\tceph-deploy mon create node1 node2 node3\n'
'If no hosts are passed it will default to use the\n'
'`mon initial members` defined in the configuration.')
)
mon_create.add_argument(
'--keyrings',
nargs='?',
help='concatenate multiple keyrings to be seeded on new monitors',
)
mon_create.add_argument(
'mon',
nargs='*',
)
mon_create_initial = mon_parser.add_parser(
'create-initial',
help=('Will deploy for monitors defined in `mon initial members`, '
'wait until they form quorum and then gatherkeys, reporting '
'the monitor status along the process. If monitors don\'t form '
'quorum the command will eventually time out.')
)
mon_create_initial.add_argument(
'--keyrings',
nargs='?',
help='concatenate multiple keyrings to be seeded on new monitors',
)
mon_destroy = mon_parser.add_parser(
'destroy',
help='Completely remove Ceph MON from remote host(s)'
)
mon_destroy.add_argument(
'mon',
nargs='+',
)
parser.set_defaults(
func=mon,
) | python | def make(parser):
parser.formatter_class = ToggleRawTextHelpFormatter
mon_parser = parser.add_subparsers(dest='subcommand')
mon_parser.required = True
mon_add = mon_parser.add_parser(
'add',
help=('R|Add a monitor to an existing cluster:\n'
'\tceph-deploy mon add node1\n'
'Or:\n'
'\tceph-deploy mon add --address 192.168.1.10 node1\n'
'If the section for the monitor exists and defines a `mon addr` that\n'
'will be used, otherwise it will fallback by resolving the hostname to an\n'
'IP. If `--address` is used it will override all other options.')
)
mon_add.add_argument(
'--address',
nargs='?',
)
mon_add.add_argument(
'mon',
nargs=1,
)
mon_create = mon_parser.add_parser(
'create',
help=('R|Deploy monitors by specifying them like:\n'
'\tceph-deploy mon create node1 node2 node3\n'
'If no hosts are passed it will default to use the\n'
'`mon initial members` defined in the configuration.')
)
mon_create.add_argument(
'--keyrings',
nargs='?',
help='concatenate multiple keyrings to be seeded on new monitors',
)
mon_create.add_argument(
'mon',
nargs='*',
)
mon_create_initial = mon_parser.add_parser(
'create-initial',
help=('Will deploy for monitors defined in `mon initial members`, '
'wait until they form quorum and then gatherkeys, reporting '
'the monitor status along the process. If monitors don\'t form '
'quorum the command will eventually time out.')
)
mon_create_initial.add_argument(
'--keyrings',
nargs='?',
help='concatenate multiple keyrings to be seeded on new monitors',
)
mon_destroy = mon_parser.add_parser(
'destroy',
help='Completely remove Ceph MON from remote host(s)'
)
mon_destroy.add_argument(
'mon',
nargs='+',
)
parser.set_defaults(
func=mon,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"parser",
".",
"formatter_class",
"=",
"ToggleRawTextHelpFormatter",
"mon_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"mon_parser",
".",
"required",
"=",
"True",
"mon_add",
"=",
"mon_parser",
".",
"add_parser",
"(",
"'add'",
",",
"help",
"=",
"(",
"'R|Add a monitor to an existing cluster:\\n'",
"'\\tceph-deploy mon add node1\\n'",
"'Or:\\n'",
"'\\tceph-deploy mon add --address 192.168.1.10 node1\\n'",
"'If the section for the monitor exists and defines a `mon addr` that\\n'",
"'will be used, otherwise it will fallback by resolving the hostname to an\\n'",
"'IP. If `--address` is used it will override all other options.'",
")",
")",
"mon_add",
".",
"add_argument",
"(",
"'--address'",
",",
"nargs",
"=",
"'?'",
",",
")",
"mon_add",
".",
"add_argument",
"(",
"'mon'",
",",
"nargs",
"=",
"1",
",",
")",
"mon_create",
"=",
"mon_parser",
".",
"add_parser",
"(",
"'create'",
",",
"help",
"=",
"(",
"'R|Deploy monitors by specifying them like:\\n'",
"'\\tceph-deploy mon create node1 node2 node3\\n'",
"'If no hosts are passed it will default to use the\\n'",
"'`mon initial members` defined in the configuration.'",
")",
")",
"mon_create",
".",
"add_argument",
"(",
"'--keyrings'",
",",
"nargs",
"=",
"'?'",
",",
"help",
"=",
"'concatenate multiple keyrings to be seeded on new monitors'",
",",
")",
"mon_create",
".",
"add_argument",
"(",
"'mon'",
",",
"nargs",
"=",
"'*'",
",",
")",
"mon_create_initial",
"=",
"mon_parser",
".",
"add_parser",
"(",
"'create-initial'",
",",
"help",
"=",
"(",
"'Will deploy for monitors defined in `mon initial members`, '",
"'wait until they form quorum and then gatherkeys, reporting '",
"'the monitor status along the process. If monitors don\\'t form '",
"'quorum the command will eventually time out.'",
")",
")",
"mon_create_initial",
".",
"add_argument",
"(",
"'--keyrings'",
",",
"nargs",
"=",
"'?'",
",",
"help",
"=",
"'concatenate multiple keyrings to be seeded on new monitors'",
",",
")",
"mon_destroy",
"=",
"mon_parser",
".",
"add_parser",
"(",
"'destroy'",
",",
"help",
"=",
"'Completely remove Ceph MON from remote host(s)'",
")",
"mon_destroy",
".",
"add_argument",
"(",
"'mon'",
",",
"nargs",
"=",
"'+'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"mon",
",",
")"
] | Ceph MON Daemon management | [
"Ceph",
"MON",
"Daemon",
"management"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L476-L545 |
247,214 | ceph/ceph-deploy | ceph_deploy/mon.py | get_mon_initial_members | def get_mon_initial_members(args, error_on_empty=False, _cfg=None):
"""
Read the Ceph config file and return the value of mon_initial_members
Optionally, a NeedHostError can be raised if the value is None.
"""
if _cfg:
cfg = _cfg
else:
cfg = conf.ceph.load(args)
mon_initial_members = cfg.safe_get('global', 'mon_initial_members')
if not mon_initial_members:
if error_on_empty:
raise exc.NeedHostError(
'could not find `mon initial members` defined in ceph.conf'
)
else:
mon_initial_members = re.split(r'[,\s]+', mon_initial_members)
return mon_initial_members | python | def get_mon_initial_members(args, error_on_empty=False, _cfg=None):
if _cfg:
cfg = _cfg
else:
cfg = conf.ceph.load(args)
mon_initial_members = cfg.safe_get('global', 'mon_initial_members')
if not mon_initial_members:
if error_on_empty:
raise exc.NeedHostError(
'could not find `mon initial members` defined in ceph.conf'
)
else:
mon_initial_members = re.split(r'[,\s]+', mon_initial_members)
return mon_initial_members | [
"def",
"get_mon_initial_members",
"(",
"args",
",",
"error_on_empty",
"=",
"False",
",",
"_cfg",
"=",
"None",
")",
":",
"if",
"_cfg",
":",
"cfg",
"=",
"_cfg",
"else",
":",
"cfg",
"=",
"conf",
".",
"ceph",
".",
"load",
"(",
"args",
")",
"mon_initial_members",
"=",
"cfg",
".",
"safe_get",
"(",
"'global'",
",",
"'mon_initial_members'",
")",
"if",
"not",
"mon_initial_members",
":",
"if",
"error_on_empty",
":",
"raise",
"exc",
".",
"NeedHostError",
"(",
"'could not find `mon initial members` defined in ceph.conf'",
")",
"else",
":",
"mon_initial_members",
"=",
"re",
".",
"split",
"(",
"r'[,\\s]+'",
",",
"mon_initial_members",
")",
"return",
"mon_initial_members"
] | Read the Ceph config file and return the value of mon_initial_members
Optionally, a NeedHostError can be raised if the value is None. | [
"Read",
"the",
"Ceph",
"config",
"file",
"and",
"return",
"the",
"value",
"of",
"mon_initial_members",
"Optionally",
"a",
"NeedHostError",
"can",
"be",
"raised",
"if",
"the",
"value",
"is",
"None",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L552-L569 |
247,215 | ceph/ceph-deploy | ceph_deploy/mon.py | is_running | def is_running(conn, args):
"""
Run a command to check the status of a mon, return a boolean.
We heavily depend on the format of the output, if that ever changes
we need to modify this.
Check daemon status for 3 times
output of the status should be similar to::
mon.mira094: running {"version":"0.61.5"}
or when it fails::
mon.mira094: dead {"version":"0.61.5"}
mon.mira094: not running {"version":"0.61.5"}
"""
stdout, stderr, _ = remoto.process.check(
conn,
args
)
result_string = b' '.join(stdout)
for run_check in [b': running', b' start/running']:
if run_check in result_string:
return True
return False | python | def is_running(conn, args):
stdout, stderr, _ = remoto.process.check(
conn,
args
)
result_string = b' '.join(stdout)
for run_check in [b': running', b' start/running']:
if run_check in result_string:
return True
return False | [
"def",
"is_running",
"(",
"conn",
",",
"args",
")",
":",
"stdout",
",",
"stderr",
",",
"_",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"conn",
",",
"args",
")",
"result_string",
"=",
"b' '",
".",
"join",
"(",
"stdout",
")",
"for",
"run_check",
"in",
"[",
"b': running'",
",",
"b' start/running'",
"]",
":",
"if",
"run_check",
"in",
"result_string",
":",
"return",
"True",
"return",
"False"
] | Run a command to check the status of a mon, return a boolean.
We heavily depend on the format of the output, if that ever changes
we need to modify this.
Check daemon status for 3 times
output of the status should be similar to::
mon.mira094: running {"version":"0.61.5"}
or when it fails::
mon.mira094: dead {"version":"0.61.5"}
mon.mira094: not running {"version":"0.61.5"} | [
"Run",
"a",
"command",
"to",
"check",
"the",
"status",
"of",
"a",
"mon",
"return",
"a",
"boolean",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mon.py#L572-L596 |
247,216 | ceph/ceph-deploy | ceph_deploy/util/system.py | executable_path | def executable_path(conn, executable):
"""
Remote validator that accepts a connection object to ensure that a certain
executable is available returning its full path if so.
Otherwise an exception with thorough details will be raised, informing the
user that the executable was not found.
"""
executable_path = conn.remote_module.which(executable)
if not executable_path:
raise ExecutableNotFound(executable, conn.hostname)
return executable_path | python | def executable_path(conn, executable):
executable_path = conn.remote_module.which(executable)
if not executable_path:
raise ExecutableNotFound(executable, conn.hostname)
return executable_path | [
"def",
"executable_path",
"(",
"conn",
",",
"executable",
")",
":",
"executable_path",
"=",
"conn",
".",
"remote_module",
".",
"which",
"(",
"executable",
")",
"if",
"not",
"executable_path",
":",
"raise",
"ExecutableNotFound",
"(",
"executable",
",",
"conn",
".",
"hostname",
")",
"return",
"executable_path"
] | Remote validator that accepts a connection object to ensure that a certain
executable is available returning its full path if so.
Otherwise an exception with thorough details will be raised, informing the
user that the executable was not found. | [
"Remote",
"validator",
"that",
"accepts",
"a",
"connection",
"object",
"to",
"ensure",
"that",
"a",
"certain",
"executable",
"is",
"available",
"returning",
"its",
"full",
"path",
"if",
"so",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/system.py#L5-L16 |
247,217 | ceph/ceph-deploy | ceph_deploy/util/system.py | is_systemd_service_enabled | def is_systemd_service_enabled(conn, service='ceph'):
"""
Detects if a systemd service is enabled or not.
"""
_, _, returncode = remoto.process.check(
conn,
[
'systemctl',
'is-enabled',
'--quiet',
'{service}'.format(service=service),
]
)
return returncode == 0 | python | def is_systemd_service_enabled(conn, service='ceph'):
_, _, returncode = remoto.process.check(
conn,
[
'systemctl',
'is-enabled',
'--quiet',
'{service}'.format(service=service),
]
)
return returncode == 0 | [
"def",
"is_systemd_service_enabled",
"(",
"conn",
",",
"service",
"=",
"'ceph'",
")",
":",
"_",
",",
"_",
",",
"returncode",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"conn",
",",
"[",
"'systemctl'",
",",
"'is-enabled'",
",",
"'--quiet'",
",",
"'{service}'",
".",
"format",
"(",
"service",
"=",
"service",
")",
",",
"]",
")",
"return",
"returncode",
"==",
"0"
] | Detects if a systemd service is enabled or not. | [
"Detects",
"if",
"a",
"systemd",
"service",
"is",
"enabled",
"or",
"not",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/system.py#L167-L180 |
247,218 | ceph/ceph-deploy | ceph_deploy/repo.py | make | def make(parser):
"""
Repo definition management
"""
parser.add_argument(
'repo_name',
metavar='REPO-NAME',
help='Name of repo to manage. Can match an entry in cephdeploy.conf'
)
parser.add_argument(
'--repo-url',
help='a repo URL that mirrors/contains Ceph packages'
)
parser.add_argument(
'--gpg-url',
help='a GPG key URL to be used with custom repos'
)
parser.add_argument(
'--remove', '--delete',
action='store_true',
help='remove repo definition on remote host'
)
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='host(s) to install on'
)
parser.set_defaults(
func=repo
) | python | def make(parser):
parser.add_argument(
'repo_name',
metavar='REPO-NAME',
help='Name of repo to manage. Can match an entry in cephdeploy.conf'
)
parser.add_argument(
'--repo-url',
help='a repo URL that mirrors/contains Ceph packages'
)
parser.add_argument(
'--gpg-url',
help='a GPG key URL to be used with custom repos'
)
parser.add_argument(
'--remove', '--delete',
action='store_true',
help='remove repo definition on remote host'
)
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='host(s) to install on'
)
parser.set_defaults(
func=repo
) | [
"def",
"make",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'repo_name'",
",",
"metavar",
"=",
"'REPO-NAME'",
",",
"help",
"=",
"'Name of repo to manage. Can match an entry in cephdeploy.conf'",
")",
"parser",
".",
"add_argument",
"(",
"'--repo-url'",
",",
"help",
"=",
"'a repo URL that mirrors/contains Ceph packages'",
")",
"parser",
".",
"add_argument",
"(",
"'--gpg-url'",
",",
"help",
"=",
"'a GPG key URL to be used with custom repos'",
")",
"parser",
".",
"add_argument",
"(",
"'--remove'",
",",
"'--delete'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'remove repo definition on remote host'",
")",
"parser",
".",
"add_argument",
"(",
"'host'",
",",
"metavar",
"=",
"'HOST'",
",",
"nargs",
"=",
"'+'",
",",
"help",
"=",
"'host(s) to install on'",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"repo",
")"
] | Repo definition management | [
"Repo",
"definition",
"management"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/repo.py#L77-L113 |
247,219 | ceph/ceph-deploy | ceph_deploy/conf/cephdeploy.py | Conf.get_list | def get_list(self, section, key):
"""
Assumes that the value for a given key is going to be a list
separated by commas. It gets rid of trailing comments.
If just one item is present it returns a list with a single item, if no
key is found an empty list is returned.
"""
value = self.get_safe(section, key, [])
if value == []:
return value
# strip comments
value = re.split(r'\s+#', value)[0]
# split on commas
value = value.split(',')
# strip spaces
return [x.strip() for x in value] | python | def get_list(self, section, key):
value = self.get_safe(section, key, [])
if value == []:
return value
# strip comments
value = re.split(r'\s+#', value)[0]
# split on commas
value = value.split(',')
# strip spaces
return [x.strip() for x in value] | [
"def",
"get_list",
"(",
"self",
",",
"section",
",",
"key",
")",
":",
"value",
"=",
"self",
".",
"get_safe",
"(",
"section",
",",
"key",
",",
"[",
"]",
")",
"if",
"value",
"==",
"[",
"]",
":",
"return",
"value",
"# strip comments",
"value",
"=",
"re",
".",
"split",
"(",
"r'\\s+#'",
",",
"value",
")",
"[",
"0",
"]",
"# split on commas",
"value",
"=",
"value",
".",
"split",
"(",
"','",
")",
"# strip spaces",
"return",
"[",
"x",
".",
"strip",
"(",
")",
"for",
"x",
"in",
"value",
"]"
] | Assumes that the value for a given key is going to be a list
separated by commas. It gets rid of trailing comments.
If just one item is present it returns a list with a single item, if no
key is found an empty list is returned. | [
"Assumes",
"that",
"the",
"value",
"for",
"a",
"given",
"key",
"is",
"going",
"to",
"be",
"a",
"list",
"separated",
"by",
"commas",
".",
"It",
"gets",
"rid",
"of",
"trailing",
"comments",
".",
"If",
"just",
"one",
"item",
"is",
"present",
"it",
"returns",
"a",
"list",
"with",
"a",
"single",
"item",
"if",
"no",
"key",
"is",
"found",
"an",
"empty",
"list",
"is",
"returned",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/conf/cephdeploy.py#L189-L207 |
247,220 | ceph/ceph-deploy | ceph_deploy/conf/cephdeploy.py | Conf.get_default_repo | def get_default_repo(self):
"""
Go through all the repositories defined in the config file and search
for a truthy value for the ``default`` key. If there isn't any return
None.
"""
for repo in self.get_repos():
if self.get_safe(repo, 'default') and self.getboolean(repo, 'default'):
return repo
return False | python | def get_default_repo(self):
for repo in self.get_repos():
if self.get_safe(repo, 'default') and self.getboolean(repo, 'default'):
return repo
return False | [
"def",
"get_default_repo",
"(",
"self",
")",
":",
"for",
"repo",
"in",
"self",
".",
"get_repos",
"(",
")",
":",
"if",
"self",
".",
"get_safe",
"(",
"repo",
",",
"'default'",
")",
"and",
"self",
".",
"getboolean",
"(",
"repo",
",",
"'default'",
")",
":",
"return",
"repo",
"return",
"False"
] | Go through all the repositories defined in the config file and search
for a truthy value for the ``default`` key. If there isn't any return
None. | [
"Go",
"through",
"all",
"the",
"repositories",
"defined",
"in",
"the",
"config",
"file",
"and",
"search",
"for",
"a",
"truthy",
"value",
"for",
"the",
"default",
"key",
".",
"If",
"there",
"isn",
"t",
"any",
"return",
"None",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/conf/cephdeploy.py#L209-L218 |
247,221 | ceph/ceph-deploy | ceph_deploy/new.py | validate_host_ip | def validate_host_ip(ips, subnets):
"""
Make sure that a given host all subnets specified will have at least one IP
in that range.
"""
# Make sure we prune ``None`` arguments
subnets = [s for s in subnets if s is not None]
validate_one_subnet = len(subnets) == 1
def ip_in_one_subnet(ips, subnet):
""" ensure an ip exists in at least one subnet """
for ip in ips:
if net.ip_in_subnet(ip, subnet):
return True
return False
for subnet in subnets:
if ip_in_one_subnet(ips, subnet):
if validate_one_subnet:
return
else: # keep going to make sure the other subnets are ok
continue
else:
msg = "subnet (%s) is not valid for any of the ips found %s" % (subnet, str(ips))
raise RuntimeError(msg) | python | def validate_host_ip(ips, subnets):
# Make sure we prune ``None`` arguments
subnets = [s for s in subnets if s is not None]
validate_one_subnet = len(subnets) == 1
def ip_in_one_subnet(ips, subnet):
""" ensure an ip exists in at least one subnet """
for ip in ips:
if net.ip_in_subnet(ip, subnet):
return True
return False
for subnet in subnets:
if ip_in_one_subnet(ips, subnet):
if validate_one_subnet:
return
else: # keep going to make sure the other subnets are ok
continue
else:
msg = "subnet (%s) is not valid for any of the ips found %s" % (subnet, str(ips))
raise RuntimeError(msg) | [
"def",
"validate_host_ip",
"(",
"ips",
",",
"subnets",
")",
":",
"# Make sure we prune ``None`` arguments",
"subnets",
"=",
"[",
"s",
"for",
"s",
"in",
"subnets",
"if",
"s",
"is",
"not",
"None",
"]",
"validate_one_subnet",
"=",
"len",
"(",
"subnets",
")",
"==",
"1",
"def",
"ip_in_one_subnet",
"(",
"ips",
",",
"subnet",
")",
":",
"\"\"\" ensure an ip exists in at least one subnet \"\"\"",
"for",
"ip",
"in",
"ips",
":",
"if",
"net",
".",
"ip_in_subnet",
"(",
"ip",
",",
"subnet",
")",
":",
"return",
"True",
"return",
"False",
"for",
"subnet",
"in",
"subnets",
":",
"if",
"ip_in_one_subnet",
"(",
"ips",
",",
"subnet",
")",
":",
"if",
"validate_one_subnet",
":",
"return",
"else",
":",
"# keep going to make sure the other subnets are ok",
"continue",
"else",
":",
"msg",
"=",
"\"subnet (%s) is not valid for any of the ips found %s\"",
"%",
"(",
"subnet",
",",
"str",
"(",
"ips",
")",
")",
"raise",
"RuntimeError",
"(",
"msg",
")"
] | Make sure that a given host all subnets specified will have at least one IP
in that range. | [
"Make",
"sure",
"that",
"a",
"given",
"host",
"all",
"subnets",
"specified",
"will",
"have",
"at",
"least",
"one",
"IP",
"in",
"that",
"range",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/new.py#L78-L102 |
247,222 | ceph/ceph-deploy | ceph_deploy/new.py | get_public_network_ip | def get_public_network_ip(ips, public_subnet):
"""
Given a public subnet, chose the one IP from the remote host that exists
within the subnet range.
"""
for ip in ips:
if net.ip_in_subnet(ip, public_subnet):
return ip
msg = "IPs (%s) are not valid for any of subnet specified %s" % (str(ips), str(public_subnet))
raise RuntimeError(msg) | python | def get_public_network_ip(ips, public_subnet):
for ip in ips:
if net.ip_in_subnet(ip, public_subnet):
return ip
msg = "IPs (%s) are not valid for any of subnet specified %s" % (str(ips), str(public_subnet))
raise RuntimeError(msg) | [
"def",
"get_public_network_ip",
"(",
"ips",
",",
"public_subnet",
")",
":",
"for",
"ip",
"in",
"ips",
":",
"if",
"net",
".",
"ip_in_subnet",
"(",
"ip",
",",
"public_subnet",
")",
":",
"return",
"ip",
"msg",
"=",
"\"IPs (%s) are not valid for any of subnet specified %s\"",
"%",
"(",
"str",
"(",
"ips",
")",
",",
"str",
"(",
"public_subnet",
")",
")",
"raise",
"RuntimeError",
"(",
"msg",
")"
] | Given a public subnet, chose the one IP from the remote host that exists
within the subnet range. | [
"Given",
"a",
"public",
"subnet",
"chose",
"the",
"one",
"IP",
"from",
"the",
"remote",
"host",
"that",
"exists",
"within",
"the",
"subnet",
"range",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/new.py#L105-L114 |
247,223 | ceph/ceph-deploy | ceph_deploy/new.py | make | def make(parser):
"""
Start deploying a new cluster, and write a CLUSTER.conf and keyring for it.
"""
parser.add_argument(
'mon',
metavar='MON',
nargs='+',
help='initial monitor hostname, fqdn, or hostname:fqdn pair',
type=arg_validators.Hostname(),
)
parser.add_argument(
'--no-ssh-copykey',
dest='ssh_copykey',
action='store_false',
default=True,
help='do not attempt to copy SSH keys',
)
parser.add_argument(
'--fsid',
dest='fsid',
help='provide an alternate FSID for ceph.conf generation',
)
parser.add_argument(
'--cluster-network',
help='specify the (internal) cluster network',
type=arg_validators.Subnet(),
)
parser.add_argument(
'--public-network',
help='specify the public network for a cluster',
type=arg_validators.Subnet(),
)
parser.set_defaults(
func=new,
) | python | def make(parser):
parser.add_argument(
'mon',
metavar='MON',
nargs='+',
help='initial monitor hostname, fqdn, or hostname:fqdn pair',
type=arg_validators.Hostname(),
)
parser.add_argument(
'--no-ssh-copykey',
dest='ssh_copykey',
action='store_false',
default=True,
help='do not attempt to copy SSH keys',
)
parser.add_argument(
'--fsid',
dest='fsid',
help='provide an alternate FSID for ceph.conf generation',
)
parser.add_argument(
'--cluster-network',
help='specify the (internal) cluster network',
type=arg_validators.Subnet(),
)
parser.add_argument(
'--public-network',
help='specify the public network for a cluster',
type=arg_validators.Subnet(),
)
parser.set_defaults(
func=new,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'mon'",
",",
"metavar",
"=",
"'MON'",
",",
"nargs",
"=",
"'+'",
",",
"help",
"=",
"'initial monitor hostname, fqdn, or hostname:fqdn pair'",
",",
"type",
"=",
"arg_validators",
".",
"Hostname",
"(",
")",
",",
")",
"parser",
".",
"add_argument",
"(",
"'--no-ssh-copykey'",
",",
"dest",
"=",
"'ssh_copykey'",
",",
"action",
"=",
"'store_false'",
",",
"default",
"=",
"True",
",",
"help",
"=",
"'do not attempt to copy SSH keys'",
",",
")",
"parser",
".",
"add_argument",
"(",
"'--fsid'",
",",
"dest",
"=",
"'fsid'",
",",
"help",
"=",
"'provide an alternate FSID for ceph.conf generation'",
",",
")",
"parser",
".",
"add_argument",
"(",
"'--cluster-network'",
",",
"help",
"=",
"'specify the (internal) cluster network'",
",",
"type",
"=",
"arg_validators",
".",
"Subnet",
"(",
")",
",",
")",
"parser",
".",
"add_argument",
"(",
"'--public-network'",
",",
"help",
"=",
"'specify the public network for a cluster'",
",",
"type",
"=",
"arg_validators",
".",
"Subnet",
"(",
")",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"new",
",",
")"
] | Start deploying a new cluster, and write a CLUSTER.conf and keyring for it. | [
"Start",
"deploying",
"a",
"new",
"cluster",
"and",
"write",
"a",
"CLUSTER",
".",
"conf",
"and",
"keyring",
"for",
"it",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/new.py#L237-L276 |
247,224 | ceph/ceph-deploy | ceph_deploy/mds.py | make | def make(parser):
"""
Ceph MDS daemon management
"""
mds_parser = parser.add_subparsers(dest='subcommand')
mds_parser.required = True
mds_create = mds_parser.add_parser(
'create',
help='Deploy Ceph MDS on remote host(s)'
)
mds_create.add_argument(
'mds',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on',
)
parser.set_defaults(
func=mds,
) | python | def make(parser):
mds_parser = parser.add_subparsers(dest='subcommand')
mds_parser.required = True
mds_create = mds_parser.add_parser(
'create',
help='Deploy Ceph MDS on remote host(s)'
)
mds_create.add_argument(
'mds',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on',
)
parser.set_defaults(
func=mds,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"mds_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"mds_parser",
".",
"required",
"=",
"True",
"mds_create",
"=",
"mds_parser",
".",
"add_parser",
"(",
"'create'",
",",
"help",
"=",
"'Deploy Ceph MDS on remote host(s)'",
")",
"mds_create",
".",
"add_argument",
"(",
"'mds'",
",",
"metavar",
"=",
"'HOST[:NAME]'",
",",
"nargs",
"=",
"'+'",
",",
"type",
"=",
"colon_separated",
",",
"help",
"=",
"'host (and optionally the daemon name) to deploy on'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"mds",
",",
")"
] | Ceph MDS daemon management | [
"Ceph",
"MDS",
"daemon",
"management"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mds.py#L206-L226 |
247,225 | ceph/ceph-deploy | ceph_deploy/hosts/util.py | install_yum_priorities | def install_yum_priorities(distro, _yum=None):
"""
EPEL started packaging Ceph so we need to make sure that the ceph.repo we
install has a higher priority than the EPEL repo so that when installing
Ceph it will come from the repo file we create.
The name of the package changed back and forth (!) since CentOS 4:
From the CentOS wiki::
Note: This plugin has carried at least two differing names over time.
It is named yum-priorities on CentOS-5 but was named
yum-plugin-priorities on CentOS-4. CentOS-6 has reverted to
yum-plugin-priorities.
:params _yum: Used for testing, so we can inject a fake yum
"""
yum = _yum or pkg_managers.yum
package_name = 'yum-plugin-priorities'
if distro.normalized_name == 'centos':
if distro.release[0] != '6':
package_name = 'yum-priorities'
yum(distro.conn, package_name) | python | def install_yum_priorities(distro, _yum=None):
yum = _yum or pkg_managers.yum
package_name = 'yum-plugin-priorities'
if distro.normalized_name == 'centos':
if distro.release[0] != '6':
package_name = 'yum-priorities'
yum(distro.conn, package_name) | [
"def",
"install_yum_priorities",
"(",
"distro",
",",
"_yum",
"=",
"None",
")",
":",
"yum",
"=",
"_yum",
"or",
"pkg_managers",
".",
"yum",
"package_name",
"=",
"'yum-plugin-priorities'",
"if",
"distro",
".",
"normalized_name",
"==",
"'centos'",
":",
"if",
"distro",
".",
"release",
"[",
"0",
"]",
"!=",
"'6'",
":",
"package_name",
"=",
"'yum-priorities'",
"yum",
"(",
"distro",
".",
"conn",
",",
"package_name",
")"
] | EPEL started packaging Ceph so we need to make sure that the ceph.repo we
install has a higher priority than the EPEL repo so that when installing
Ceph it will come from the repo file we create.
The name of the package changed back and forth (!) since CentOS 4:
From the CentOS wiki::
Note: This plugin has carried at least two differing names over time.
It is named yum-priorities on CentOS-5 but was named
yum-plugin-priorities on CentOS-4. CentOS-6 has reverted to
yum-plugin-priorities.
:params _yum: Used for testing, so we can inject a fake yum | [
"EPEL",
"started",
"packaging",
"Ceph",
"so",
"we",
"need",
"to",
"make",
"sure",
"that",
"the",
"ceph",
".",
"repo",
"we",
"install",
"has",
"a",
"higher",
"priority",
"than",
"the",
"EPEL",
"repo",
"so",
"that",
"when",
"installing",
"Ceph",
"it",
"will",
"come",
"from",
"the",
"repo",
"file",
"we",
"create",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/util.py#L8-L31 |
247,226 | ceph/ceph-deploy | ceph_deploy/util/decorators.py | make_exception_message | def make_exception_message(exc):
"""
An exception is passed in and this function
returns the proper string depending on the result
so it is readable enough.
"""
if str(exc):
return '%s: %s\n' % (exc.__class__.__name__, exc)
else:
return '%s\n' % (exc.__class__.__name__) | python | def make_exception_message(exc):
if str(exc):
return '%s: %s\n' % (exc.__class__.__name__, exc)
else:
return '%s\n' % (exc.__class__.__name__) | [
"def",
"make_exception_message",
"(",
"exc",
")",
":",
"if",
"str",
"(",
"exc",
")",
":",
"return",
"'%s: %s\\n'",
"%",
"(",
"exc",
".",
"__class__",
".",
"__name__",
",",
"exc",
")",
"else",
":",
"return",
"'%s\\n'",
"%",
"(",
"exc",
".",
"__class__",
".",
"__name__",
")"
] | An exception is passed in and this function
returns the proper string depending on the result
so it is readable enough. | [
"An",
"exception",
"is",
"passed",
"in",
"and",
"this",
"function",
"returns",
"the",
"proper",
"string",
"depending",
"on",
"the",
"result",
"so",
"it",
"is",
"readable",
"enough",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/decorators.py#L102-L111 |
247,227 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | platform_information | def platform_information(_linux_distribution=None):
""" detect platform information from remote host """
linux_distribution = _linux_distribution or platform.linux_distribution
distro, release, codename = linux_distribution()
if not distro:
distro, release, codename = parse_os_release()
if not codename and 'debian' in distro.lower(): # this could be an empty string in Debian
debian_codenames = {
'10': 'buster',
'9': 'stretch',
'8': 'jessie',
'7': 'wheezy',
'6': 'squeeze',
}
major_version = release.split('.')[0]
codename = debian_codenames.get(major_version, '')
# In order to support newer jessie/sid or wheezy/sid strings we test this
# if sid is buried in the minor, we should use sid anyway.
if not codename and '/' in release:
major, minor = release.split('/')
if minor == 'sid':
codename = minor
else:
codename = major
if not codename and 'oracle' in distro.lower(): # this could be an empty string in Oracle linux
codename = 'oracle'
if not codename and 'virtuozzo linux' in distro.lower(): # this could be an empty string in Virtuozzo linux
codename = 'virtuozzo'
if not codename and 'arch' in distro.lower(): # this could be an empty string in Arch linux
codename = 'arch'
return (
str(distro).rstrip(),
str(release).rstrip(),
str(codename).rstrip()
) | python | def platform_information(_linux_distribution=None):
linux_distribution = _linux_distribution or platform.linux_distribution
distro, release, codename = linux_distribution()
if not distro:
distro, release, codename = parse_os_release()
if not codename and 'debian' in distro.lower(): # this could be an empty string in Debian
debian_codenames = {
'10': 'buster',
'9': 'stretch',
'8': 'jessie',
'7': 'wheezy',
'6': 'squeeze',
}
major_version = release.split('.')[0]
codename = debian_codenames.get(major_version, '')
# In order to support newer jessie/sid or wheezy/sid strings we test this
# if sid is buried in the minor, we should use sid anyway.
if not codename and '/' in release:
major, minor = release.split('/')
if minor == 'sid':
codename = minor
else:
codename = major
if not codename and 'oracle' in distro.lower(): # this could be an empty string in Oracle linux
codename = 'oracle'
if not codename and 'virtuozzo linux' in distro.lower(): # this could be an empty string in Virtuozzo linux
codename = 'virtuozzo'
if not codename and 'arch' in distro.lower(): # this could be an empty string in Arch linux
codename = 'arch'
return (
str(distro).rstrip(),
str(release).rstrip(),
str(codename).rstrip()
) | [
"def",
"platform_information",
"(",
"_linux_distribution",
"=",
"None",
")",
":",
"linux_distribution",
"=",
"_linux_distribution",
"or",
"platform",
".",
"linux_distribution",
"distro",
",",
"release",
",",
"codename",
"=",
"linux_distribution",
"(",
")",
"if",
"not",
"distro",
":",
"distro",
",",
"release",
",",
"codename",
"=",
"parse_os_release",
"(",
")",
"if",
"not",
"codename",
"and",
"'debian'",
"in",
"distro",
".",
"lower",
"(",
")",
":",
"# this could be an empty string in Debian",
"debian_codenames",
"=",
"{",
"'10'",
":",
"'buster'",
",",
"'9'",
":",
"'stretch'",
",",
"'8'",
":",
"'jessie'",
",",
"'7'",
":",
"'wheezy'",
",",
"'6'",
":",
"'squeeze'",
",",
"}",
"major_version",
"=",
"release",
".",
"split",
"(",
"'.'",
")",
"[",
"0",
"]",
"codename",
"=",
"debian_codenames",
".",
"get",
"(",
"major_version",
",",
"''",
")",
"# In order to support newer jessie/sid or wheezy/sid strings we test this",
"# if sid is buried in the minor, we should use sid anyway.",
"if",
"not",
"codename",
"and",
"'/'",
"in",
"release",
":",
"major",
",",
"minor",
"=",
"release",
".",
"split",
"(",
"'/'",
")",
"if",
"minor",
"==",
"'sid'",
":",
"codename",
"=",
"minor",
"else",
":",
"codename",
"=",
"major",
"if",
"not",
"codename",
"and",
"'oracle'",
"in",
"distro",
".",
"lower",
"(",
")",
":",
"# this could be an empty string in Oracle linux",
"codename",
"=",
"'oracle'",
"if",
"not",
"codename",
"and",
"'virtuozzo linux'",
"in",
"distro",
".",
"lower",
"(",
")",
":",
"# this could be an empty string in Virtuozzo linux",
"codename",
"=",
"'virtuozzo'",
"if",
"not",
"codename",
"and",
"'arch'",
"in",
"distro",
".",
"lower",
"(",
")",
":",
"# this could be an empty string in Arch linux",
"codename",
"=",
"'arch'",
"return",
"(",
"str",
"(",
"distro",
")",
".",
"rstrip",
"(",
")",
",",
"str",
"(",
"release",
")",
".",
"rstrip",
"(",
")",
",",
"str",
"(",
"codename",
")",
".",
"rstrip",
"(",
")",
")"
] | detect platform information from remote host | [
"detect",
"platform",
"information",
"from",
"remote",
"host"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L14-L50 |
247,228 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | write_keyring | def write_keyring(path, key, uid=-1, gid=-1):
""" create a keyring file """
# Note that we *require* to avoid deletion of the temp file
# otherwise we risk not being able to copy the contents from
# one file system to the other, hence the `delete=False`
tmp_file = tempfile.NamedTemporaryFile('wb', delete=False)
tmp_file.write(key)
tmp_file.close()
keyring_dir = os.path.dirname(path)
if not path_exists(keyring_dir):
makedir(keyring_dir, uid, gid)
shutil.move(tmp_file.name, path) | python | def write_keyring(path, key, uid=-1, gid=-1):
# Note that we *require* to avoid deletion of the temp file
# otherwise we risk not being able to copy the contents from
# one file system to the other, hence the `delete=False`
tmp_file = tempfile.NamedTemporaryFile('wb', delete=False)
tmp_file.write(key)
tmp_file.close()
keyring_dir = os.path.dirname(path)
if not path_exists(keyring_dir):
makedir(keyring_dir, uid, gid)
shutil.move(tmp_file.name, path) | [
"def",
"write_keyring",
"(",
"path",
",",
"key",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"# Note that we *require* to avoid deletion of the temp file",
"# otherwise we risk not being able to copy the contents from",
"# one file system to the other, hence the `delete=False`",
"tmp_file",
"=",
"tempfile",
".",
"NamedTemporaryFile",
"(",
"'wb'",
",",
"delete",
"=",
"False",
")",
"tmp_file",
".",
"write",
"(",
"key",
")",
"tmp_file",
".",
"close",
"(",
")",
"keyring_dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"path",
")",
"if",
"not",
"path_exists",
"(",
"keyring_dir",
")",
":",
"makedir",
"(",
"keyring_dir",
",",
"uid",
",",
"gid",
")",
"shutil",
".",
"move",
"(",
"tmp_file",
".",
"name",
",",
"path",
")"
] | create a keyring file | [
"create",
"a",
"keyring",
"file"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L178-L189 |
247,229 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | create_mon_path | def create_mon_path(path, uid=-1, gid=-1):
"""create the mon path if it does not exist"""
if not os.path.exists(path):
os.makedirs(path)
os.chown(path, uid, gid); | python | def create_mon_path(path, uid=-1, gid=-1):
if not os.path.exists(path):
os.makedirs(path)
os.chown(path, uid, gid); | [
"def",
"create_mon_path",
"(",
"path",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
":",
"os",
".",
"makedirs",
"(",
"path",
")",
"os",
".",
"chown",
"(",
"path",
",",
"uid",
",",
"gid",
")"
] | create the mon path if it does not exist | [
"create",
"the",
"mon",
"path",
"if",
"it",
"does",
"not",
"exist"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L192-L196 |
247,230 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | create_done_path | def create_done_path(done_path, uid=-1, gid=-1):
"""create a done file to avoid re-doing the mon deployment"""
with open(done_path, 'wb'):
pass
os.chown(done_path, uid, gid); | python | def create_done_path(done_path, uid=-1, gid=-1):
with open(done_path, 'wb'):
pass
os.chown(done_path, uid, gid); | [
"def",
"create_done_path",
"(",
"done_path",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"with",
"open",
"(",
"done_path",
",",
"'wb'",
")",
":",
"pass",
"os",
".",
"chown",
"(",
"done_path",
",",
"uid",
",",
"gid",
")"
] | create a done file to avoid re-doing the mon deployment | [
"create",
"a",
"done",
"file",
"to",
"avoid",
"re",
"-",
"doing",
"the",
"mon",
"deployment"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L199-L203 |
247,231 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | create_init_path | def create_init_path(init_path, uid=-1, gid=-1):
"""create the init path if it does not exist"""
if not os.path.exists(init_path):
with open(init_path, 'wb'):
pass
os.chown(init_path, uid, gid); | python | def create_init_path(init_path, uid=-1, gid=-1):
if not os.path.exists(init_path):
with open(init_path, 'wb'):
pass
os.chown(init_path, uid, gid); | [
"def",
"create_init_path",
"(",
"init_path",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"init_path",
")",
":",
"with",
"open",
"(",
"init_path",
",",
"'wb'",
")",
":",
"pass",
"os",
".",
"chown",
"(",
"init_path",
",",
"uid",
",",
"gid",
")"
] | create the init path if it does not exist | [
"create",
"the",
"init",
"path",
"if",
"it",
"does",
"not",
"exist"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L206-L211 |
247,232 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | write_monitor_keyring | def write_monitor_keyring(keyring, monitor_keyring, uid=-1, gid=-1):
"""create the monitor keyring file"""
write_file(keyring, monitor_keyring, 0o600, None, uid, gid) | python | def write_monitor_keyring(keyring, monitor_keyring, uid=-1, gid=-1):
write_file(keyring, monitor_keyring, 0o600, None, uid, gid) | [
"def",
"write_monitor_keyring",
"(",
"keyring",
",",
"monitor_keyring",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"write_file",
"(",
"keyring",
",",
"monitor_keyring",
",",
"0o600",
",",
"None",
",",
"uid",
",",
"gid",
")"
] | create the monitor keyring file | [
"create",
"the",
"monitor",
"keyring",
"file"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L260-L262 |
247,233 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | which | def which(executable):
"""find the location of an executable"""
locations = (
'/usr/local/bin',
'/bin',
'/usr/bin',
'/usr/local/sbin',
'/usr/sbin',
'/sbin',
)
for location in locations:
executable_path = os.path.join(location, executable)
if os.path.exists(executable_path) and os.path.isfile(executable_path):
return executable_path | python | def which(executable):
locations = (
'/usr/local/bin',
'/bin',
'/usr/bin',
'/usr/local/sbin',
'/usr/sbin',
'/sbin',
)
for location in locations:
executable_path = os.path.join(location, executable)
if os.path.exists(executable_path) and os.path.isfile(executable_path):
return executable_path | [
"def",
"which",
"(",
"executable",
")",
":",
"locations",
"=",
"(",
"'/usr/local/bin'",
",",
"'/bin'",
",",
"'/usr/bin'",
",",
"'/usr/local/sbin'",
",",
"'/usr/sbin'",
",",
"'/sbin'",
",",
")",
"for",
"location",
"in",
"locations",
":",
"executable_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"location",
",",
"executable",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"executable_path",
")",
"and",
"os",
".",
"path",
".",
"isfile",
"(",
"executable_path",
")",
":",
"return",
"executable_path"
] | find the location of an executable | [
"find",
"the",
"location",
"of",
"an",
"executable"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L331-L345 |
247,234 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | make_mon_removed_dir | def make_mon_removed_dir(path, file_name):
""" move old monitor data """
try:
os.makedirs('/var/lib/ceph/mon-removed')
except OSError as e:
if e.errno != errno.EEXIST:
raise
shutil.move(path, os.path.join('/var/lib/ceph/mon-removed/', file_name)) | python | def make_mon_removed_dir(path, file_name):
try:
os.makedirs('/var/lib/ceph/mon-removed')
except OSError as e:
if e.errno != errno.EEXIST:
raise
shutil.move(path, os.path.join('/var/lib/ceph/mon-removed/', file_name)) | [
"def",
"make_mon_removed_dir",
"(",
"path",
",",
"file_name",
")",
":",
"try",
":",
"os",
".",
"makedirs",
"(",
"'/var/lib/ceph/mon-removed'",
")",
"except",
"OSError",
"as",
"e",
":",
"if",
"e",
".",
"errno",
"!=",
"errno",
".",
"EEXIST",
":",
"raise",
"shutil",
".",
"move",
"(",
"path",
",",
"os",
".",
"path",
".",
"join",
"(",
"'/var/lib/ceph/mon-removed/'",
",",
"file_name",
")",
")"
] | move old monitor data | [
"move",
"old",
"monitor",
"data"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L348-L355 |
247,235 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | safe_mkdir | def safe_mkdir(path, uid=-1, gid=-1):
""" create path if it doesn't exist """
try:
os.mkdir(path)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
else:
os.chown(path, uid, gid) | python | def safe_mkdir(path, uid=-1, gid=-1):
try:
os.mkdir(path)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
else:
os.chown(path, uid, gid) | [
"def",
"safe_mkdir",
"(",
"path",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"try",
":",
"os",
".",
"mkdir",
"(",
"path",
")",
"except",
"OSError",
"as",
"e",
":",
"if",
"e",
".",
"errno",
"==",
"errno",
".",
"EEXIST",
":",
"pass",
"else",
":",
"raise",
"else",
":",
"os",
".",
"chown",
"(",
"path",
",",
"uid",
",",
"gid",
")"
] | create path if it doesn't exist | [
"create",
"path",
"if",
"it",
"doesn",
"t",
"exist"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L358-L368 |
247,236 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | safe_makedirs | def safe_makedirs(path, uid=-1, gid=-1):
""" create path recursively if it doesn't exist """
try:
os.makedirs(path)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
else:
os.chown(path, uid, gid) | python | def safe_makedirs(path, uid=-1, gid=-1):
try:
os.makedirs(path)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
else:
os.chown(path, uid, gid) | [
"def",
"safe_makedirs",
"(",
"path",
",",
"uid",
"=",
"-",
"1",
",",
"gid",
"=",
"-",
"1",
")",
":",
"try",
":",
"os",
".",
"makedirs",
"(",
"path",
")",
"except",
"OSError",
"as",
"e",
":",
"if",
"e",
".",
"errno",
"==",
"errno",
".",
"EEXIST",
":",
"pass",
"else",
":",
"raise",
"else",
":",
"os",
".",
"chown",
"(",
"path",
",",
"uid",
",",
"gid",
")"
] | create path recursively if it doesn't exist | [
"create",
"path",
"recursively",
"if",
"it",
"doesn",
"t",
"exist"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L371-L381 |
247,237 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | zeroing | def zeroing(dev):
""" zeroing last few blocks of device """
# this kills the crab
#
# sgdisk will wipe out the main copy of the GPT partition
# table (sorry), but it doesn't remove the backup copies, and
# subsequent commands will continue to complain and fail when
# they see those. zeroing the last few blocks of the device
# appears to do the trick.
lba_size = 4096
size = 33 * lba_size
return True
with open(dev, 'wb') as f:
f.seek(-size, os.SEEK_END)
f.write(size*b'\0') | python | def zeroing(dev):
# this kills the crab
#
# sgdisk will wipe out the main copy of the GPT partition
# table (sorry), but it doesn't remove the backup copies, and
# subsequent commands will continue to complain and fail when
# they see those. zeroing the last few blocks of the device
# appears to do the trick.
lba_size = 4096
size = 33 * lba_size
return True
with open(dev, 'wb') as f:
f.seek(-size, os.SEEK_END)
f.write(size*b'\0') | [
"def",
"zeroing",
"(",
"dev",
")",
":",
"# this kills the crab",
"#",
"# sgdisk will wipe out the main copy of the GPT partition",
"# table (sorry), but it doesn't remove the backup copies, and",
"# subsequent commands will continue to complain and fail when",
"# they see those. zeroing the last few blocks of the device",
"# appears to do the trick.",
"lba_size",
"=",
"4096",
"size",
"=",
"33",
"*",
"lba_size",
"return",
"True",
"with",
"open",
"(",
"dev",
",",
"'wb'",
")",
"as",
"f",
":",
"f",
".",
"seek",
"(",
"-",
"size",
",",
"os",
".",
"SEEK_END",
")",
"f",
".",
"write",
"(",
"size",
"*",
"b'\\0'",
")"
] | zeroing last few blocks of device | [
"zeroing",
"last",
"few",
"blocks",
"of",
"device"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L384-L398 |
247,238 | ceph/ceph-deploy | ceph_deploy/hosts/remotes.py | enable_yum_priority_obsoletes | def enable_yum_priority_obsoletes(path="/etc/yum/pluginconf.d/priorities.conf"):
"""Configure Yum priorities to include obsoletes"""
config = configparser.ConfigParser()
config.read(path)
config.set('main', 'check_obsoletes', '1')
with open(path, 'w') as fout:
config.write(fout) | python | def enable_yum_priority_obsoletes(path="/etc/yum/pluginconf.d/priorities.conf"):
config = configparser.ConfigParser()
config.read(path)
config.set('main', 'check_obsoletes', '1')
with open(path, 'w') as fout:
config.write(fout) | [
"def",
"enable_yum_priority_obsoletes",
"(",
"path",
"=",
"\"/etc/yum/pluginconf.d/priorities.conf\"",
")",
":",
"config",
"=",
"configparser",
".",
"ConfigParser",
"(",
")",
"config",
".",
"read",
"(",
"path",
")",
"config",
".",
"set",
"(",
"'main'",
",",
"'check_obsoletes'",
",",
"'1'",
")",
"with",
"open",
"(",
"path",
",",
"'w'",
")",
"as",
"fout",
":",
"config",
".",
"write",
"(",
"fout",
")"
] | Configure Yum priorities to include obsoletes | [
"Configure",
"Yum",
"priorities",
"to",
"include",
"obsoletes"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/remotes.py#L401-L407 |
247,239 | ceph/ceph-deploy | vendor.py | vendorize | def vendorize(vendor_requirements):
"""
This is the main entry point for vendorizing requirements. It expects
a list of tuples that should contain the name of the library and the
version.
For example, a library ``foo`` with version ``0.0.1`` would look like::
vendor_requirements = [
('foo', '0.0.1'),
]
"""
for library in vendor_requirements:
if len(library) == 2:
name, version = library
cmd = None
elif len(library) == 3: # a possible cmd we need to run
name, version, cmd = library
vendor_library(name, version, cmd) | python | def vendorize(vendor_requirements):
for library in vendor_requirements:
if len(library) == 2:
name, version = library
cmd = None
elif len(library) == 3: # a possible cmd we need to run
name, version, cmd = library
vendor_library(name, version, cmd) | [
"def",
"vendorize",
"(",
"vendor_requirements",
")",
":",
"for",
"library",
"in",
"vendor_requirements",
":",
"if",
"len",
"(",
"library",
")",
"==",
"2",
":",
"name",
",",
"version",
"=",
"library",
"cmd",
"=",
"None",
"elif",
"len",
"(",
"library",
")",
"==",
"3",
":",
"# a possible cmd we need to run",
"name",
",",
"version",
",",
"cmd",
"=",
"library",
"vendor_library",
"(",
"name",
",",
"version",
",",
"cmd",
")"
] | This is the main entry point for vendorizing requirements. It expects
a list of tuples that should contain the name of the library and the
version.
For example, a library ``foo`` with version ``0.0.1`` would look like::
vendor_requirements = [
('foo', '0.0.1'),
] | [
"This",
"is",
"the",
"main",
"entry",
"point",
"for",
"vendorizing",
"requirements",
".",
"It",
"expects",
"a",
"list",
"of",
"tuples",
"that",
"should",
"contain",
"the",
"name",
"of",
"the",
"library",
"and",
"the",
"version",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/vendor.py#L93-L112 |
247,240 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | _keyring_equivalent | def _keyring_equivalent(keyring_one, keyring_two):
"""
Check two keyrings are identical
"""
def keyring_extract_key(file_path):
"""
Cephx keyring files may or may not have white space before some lines.
They may have some values in quotes, so a safe way to compare is to
extract the key.
"""
with open(file_path) as f:
for line in f:
content = line.strip()
if len(content) == 0:
continue
split_line = content.split('=')
if split_line[0].strip() == 'key':
return "=".join(split_line[1:]).strip()
raise RuntimeError("File '%s' is not a keyring" % file_path)
key_one = keyring_extract_key(keyring_one)
key_two = keyring_extract_key(keyring_two)
return key_one == key_two | python | def _keyring_equivalent(keyring_one, keyring_two):
def keyring_extract_key(file_path):
"""
Cephx keyring files may or may not have white space before some lines.
They may have some values in quotes, so a safe way to compare is to
extract the key.
"""
with open(file_path) as f:
for line in f:
content = line.strip()
if len(content) == 0:
continue
split_line = content.split('=')
if split_line[0].strip() == 'key':
return "=".join(split_line[1:]).strip()
raise RuntimeError("File '%s' is not a keyring" % file_path)
key_one = keyring_extract_key(keyring_one)
key_two = keyring_extract_key(keyring_two)
return key_one == key_two | [
"def",
"_keyring_equivalent",
"(",
"keyring_one",
",",
"keyring_two",
")",
":",
"def",
"keyring_extract_key",
"(",
"file_path",
")",
":",
"\"\"\"\n Cephx keyring files may or may not have white space before some lines.\n They may have some values in quotes, so a safe way to compare is to\n extract the key.\n \"\"\"",
"with",
"open",
"(",
"file_path",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"content",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"len",
"(",
"content",
")",
"==",
"0",
":",
"continue",
"split_line",
"=",
"content",
".",
"split",
"(",
"'='",
")",
"if",
"split_line",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"==",
"'key'",
":",
"return",
"\"=\"",
".",
"join",
"(",
"split_line",
"[",
"1",
":",
"]",
")",
".",
"strip",
"(",
")",
"raise",
"RuntimeError",
"(",
"\"File '%s' is not a keyring\"",
"%",
"file_path",
")",
"key_one",
"=",
"keyring_extract_key",
"(",
"keyring_one",
")",
"key_two",
"=",
"keyring_extract_key",
"(",
"keyring_two",
")",
"return",
"key_one",
"==",
"key_two"
] | Check two keyrings are identical | [
"Check",
"two",
"keyrings",
"are",
"identical"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L17-L38 |
247,241 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | keytype_path_to | def keytype_path_to(args, keytype):
"""
Get the local filename for a keyring type
"""
if keytype == "admin":
return '{cluster}.client.admin.keyring'.format(
cluster=args.cluster)
if keytype == "mon":
return '{cluster}.mon.keyring'.format(
cluster=args.cluster)
return '{cluster}.bootstrap-{what}.keyring'.format(
cluster=args.cluster,
what=keytype) | python | def keytype_path_to(args, keytype):
if keytype == "admin":
return '{cluster}.client.admin.keyring'.format(
cluster=args.cluster)
if keytype == "mon":
return '{cluster}.mon.keyring'.format(
cluster=args.cluster)
return '{cluster}.bootstrap-{what}.keyring'.format(
cluster=args.cluster,
what=keytype) | [
"def",
"keytype_path_to",
"(",
"args",
",",
"keytype",
")",
":",
"if",
"keytype",
"==",
"\"admin\"",
":",
"return",
"'{cluster}.client.admin.keyring'",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
")",
"if",
"keytype",
"==",
"\"mon\"",
":",
"return",
"'{cluster}.mon.keyring'",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
")",
"return",
"'{cluster}.bootstrap-{what}.keyring'",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
",",
"what",
"=",
"keytype",
")"
] | Get the local filename for a keyring type | [
"Get",
"the",
"local",
"filename",
"for",
"a",
"keyring",
"type"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L41-L53 |
247,242 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | gatherkeys_missing | def gatherkeys_missing(args, distro, rlogger, keypath, keytype, dest_dir):
"""
Get or create the keyring from the mon using the mon keyring by keytype and
copy to dest_dir
"""
args_prefix = [
'/usr/bin/ceph',
'--connect-timeout=25',
'--cluster={cluster}'.format(
cluster=args.cluster),
'--name', 'mon.',
'--keyring={keypath}'.format(
keypath=keypath),
]
identity = keytype_identity(keytype)
if identity is None:
raise RuntimeError('Could not find identity for keytype:%s' % keytype)
capabilites = keytype_capabilities(keytype)
if capabilites is None:
raise RuntimeError('Could not find capabilites for keytype:%s' % keytype)
# First try getting the key if it already exists, to handle the case where
# it exists but doesn't match the caps we would pass into get-or-create.
# This is the same behvaior as in newer ceph-create-keys
out, err, code = remoto.process.check(
distro.conn,
args_prefix + ['auth', 'get', identity]
)
if code == errno.ENOENT:
out, err, code = remoto.process.check(
distro.conn,
args_prefix + ['auth', 'get-or-create', identity] + capabilites
)
if code != 0:
rlogger.error(
'"ceph auth get-or-create for keytype %s returned %s',
keytype, code
)
for line in err:
rlogger.debug(line)
return False
keyring_name_local = keytype_path_to(args, keytype)
keyring_path_local = os.path.join(dest_dir, keyring_name_local)
with open(keyring_path_local, 'wb') as f:
for line in out:
f.write(line + b'\n')
return True | python | def gatherkeys_missing(args, distro, rlogger, keypath, keytype, dest_dir):
args_prefix = [
'/usr/bin/ceph',
'--connect-timeout=25',
'--cluster={cluster}'.format(
cluster=args.cluster),
'--name', 'mon.',
'--keyring={keypath}'.format(
keypath=keypath),
]
identity = keytype_identity(keytype)
if identity is None:
raise RuntimeError('Could not find identity for keytype:%s' % keytype)
capabilites = keytype_capabilities(keytype)
if capabilites is None:
raise RuntimeError('Could not find capabilites for keytype:%s' % keytype)
# First try getting the key if it already exists, to handle the case where
# it exists but doesn't match the caps we would pass into get-or-create.
# This is the same behvaior as in newer ceph-create-keys
out, err, code = remoto.process.check(
distro.conn,
args_prefix + ['auth', 'get', identity]
)
if code == errno.ENOENT:
out, err, code = remoto.process.check(
distro.conn,
args_prefix + ['auth', 'get-or-create', identity] + capabilites
)
if code != 0:
rlogger.error(
'"ceph auth get-or-create for keytype %s returned %s',
keytype, code
)
for line in err:
rlogger.debug(line)
return False
keyring_name_local = keytype_path_to(args, keytype)
keyring_path_local = os.path.join(dest_dir, keyring_name_local)
with open(keyring_path_local, 'wb') as f:
for line in out:
f.write(line + b'\n')
return True | [
"def",
"gatherkeys_missing",
"(",
"args",
",",
"distro",
",",
"rlogger",
",",
"keypath",
",",
"keytype",
",",
"dest_dir",
")",
":",
"args_prefix",
"=",
"[",
"'/usr/bin/ceph'",
",",
"'--connect-timeout=25'",
",",
"'--cluster={cluster}'",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
")",
",",
"'--name'",
",",
"'mon.'",
",",
"'--keyring={keypath}'",
".",
"format",
"(",
"keypath",
"=",
"keypath",
")",
",",
"]",
"identity",
"=",
"keytype_identity",
"(",
"keytype",
")",
"if",
"identity",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Could not find identity for keytype:%s'",
"%",
"keytype",
")",
"capabilites",
"=",
"keytype_capabilities",
"(",
"keytype",
")",
"if",
"capabilites",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Could not find capabilites for keytype:%s'",
"%",
"keytype",
")",
"# First try getting the key if it already exists, to handle the case where",
"# it exists but doesn't match the caps we would pass into get-or-create.",
"# This is the same behvaior as in newer ceph-create-keys",
"out",
",",
"err",
",",
"code",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"distro",
".",
"conn",
",",
"args_prefix",
"+",
"[",
"'auth'",
",",
"'get'",
",",
"identity",
"]",
")",
"if",
"code",
"==",
"errno",
".",
"ENOENT",
":",
"out",
",",
"err",
",",
"code",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"distro",
".",
"conn",
",",
"args_prefix",
"+",
"[",
"'auth'",
",",
"'get-or-create'",
",",
"identity",
"]",
"+",
"capabilites",
")",
"if",
"code",
"!=",
"0",
":",
"rlogger",
".",
"error",
"(",
"'\"ceph auth get-or-create for keytype %s returned %s'",
",",
"keytype",
",",
"code",
")",
"for",
"line",
"in",
"err",
":",
"rlogger",
".",
"debug",
"(",
"line",
")",
"return",
"False",
"keyring_name_local",
"=",
"keytype_path_to",
"(",
"args",
",",
"keytype",
")",
"keyring_path_local",
"=",
"os",
".",
"path",
".",
"join",
"(",
"dest_dir",
",",
"keyring_name_local",
")",
"with",
"open",
"(",
"keyring_path_local",
",",
"'wb'",
")",
"as",
"f",
":",
"for",
"line",
"in",
"out",
":",
"f",
".",
"write",
"(",
"line",
"+",
"b'\\n'",
")",
"return",
"True"
] | Get or create the keyring from the mon using the mon keyring by keytype and
copy to dest_dir | [
"Get",
"or",
"create",
"the",
"keyring",
"from",
"the",
"mon",
"using",
"the",
"mon",
"keyring",
"by",
"keytype",
"and",
"copy",
"to",
"dest_dir"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L100-L147 |
247,243 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | gatherkeys_with_mon | def gatherkeys_with_mon(args, host, dest_dir):
"""
Connect to mon and gather keys if mon is in quorum.
"""
distro = hosts.get(host, username=args.username)
remote_hostname = distro.conn.remote_module.shortname()
dir_keytype_mon = ceph_deploy.util.paths.mon.path(args.cluster, remote_hostname)
path_keytype_mon = "%s/keyring" % (dir_keytype_mon)
mon_key = distro.conn.remote_module.get_file(path_keytype_mon)
if mon_key is None:
LOG.warning("No mon key found in host: %s", host)
return False
mon_name_local = keytype_path_to(args, "mon")
mon_path_local = os.path.join(dest_dir, mon_name_local)
with open(mon_path_local, 'wb') as f:
f.write(mon_key)
rlogger = logging.getLogger(host)
path_asok = ceph_deploy.util.paths.mon.asok(args.cluster, remote_hostname)
out, err, code = remoto.process.check(
distro.conn,
[
"/usr/bin/ceph",
"--connect-timeout=25",
"--cluster={cluster}".format(
cluster=args.cluster),
"--admin-daemon={asok}".format(
asok=path_asok),
"mon_status"
]
)
if code != 0:
rlogger.error('"ceph mon_status %s" returned %s', host, code)
for line in err:
rlogger.debug(line)
return False
try:
mon_status = json.loads(b''.join(out).decode('utf-8'))
except ValueError:
rlogger.error('"ceph mon_status %s" output was not json', host)
for line in out:
rlogger.error(line)
return False
mon_number = None
mon_map = mon_status.get('monmap')
if mon_map is None:
rlogger.error("could not find mon map for mons on '%s'", host)
return False
mon_quorum = mon_status.get('quorum')
if mon_quorum is None:
rlogger.error("could not find quorum for mons on '%s'" , host)
return False
mon_map_mons = mon_map.get('mons')
if mon_map_mons is None:
rlogger.error("could not find mons in monmap on '%s'", host)
return False
for mon in mon_map_mons:
if mon.get('name') == remote_hostname:
mon_number = mon.get('rank')
break
if mon_number is None:
rlogger.error("could not find '%s' in monmap", remote_hostname)
return False
if not mon_number in mon_quorum:
rlogger.error("Not yet quorum for '%s'", host)
return False
for keytype in ["admin", "mds", "mgr", "osd", "rgw"]:
if not gatherkeys_missing(args, distro, rlogger, path_keytype_mon, keytype, dest_dir):
# We will return failure if we fail to gather any key
rlogger.error("Failed to return '%s' key from host %s", keytype, host)
return False
return True | python | def gatherkeys_with_mon(args, host, dest_dir):
distro = hosts.get(host, username=args.username)
remote_hostname = distro.conn.remote_module.shortname()
dir_keytype_mon = ceph_deploy.util.paths.mon.path(args.cluster, remote_hostname)
path_keytype_mon = "%s/keyring" % (dir_keytype_mon)
mon_key = distro.conn.remote_module.get_file(path_keytype_mon)
if mon_key is None:
LOG.warning("No mon key found in host: %s", host)
return False
mon_name_local = keytype_path_to(args, "mon")
mon_path_local = os.path.join(dest_dir, mon_name_local)
with open(mon_path_local, 'wb') as f:
f.write(mon_key)
rlogger = logging.getLogger(host)
path_asok = ceph_deploy.util.paths.mon.asok(args.cluster, remote_hostname)
out, err, code = remoto.process.check(
distro.conn,
[
"/usr/bin/ceph",
"--connect-timeout=25",
"--cluster={cluster}".format(
cluster=args.cluster),
"--admin-daemon={asok}".format(
asok=path_asok),
"mon_status"
]
)
if code != 0:
rlogger.error('"ceph mon_status %s" returned %s', host, code)
for line in err:
rlogger.debug(line)
return False
try:
mon_status = json.loads(b''.join(out).decode('utf-8'))
except ValueError:
rlogger.error('"ceph mon_status %s" output was not json', host)
for line in out:
rlogger.error(line)
return False
mon_number = None
mon_map = mon_status.get('monmap')
if mon_map is None:
rlogger.error("could not find mon map for mons on '%s'", host)
return False
mon_quorum = mon_status.get('quorum')
if mon_quorum is None:
rlogger.error("could not find quorum for mons on '%s'" , host)
return False
mon_map_mons = mon_map.get('mons')
if mon_map_mons is None:
rlogger.error("could not find mons in monmap on '%s'", host)
return False
for mon in mon_map_mons:
if mon.get('name') == remote_hostname:
mon_number = mon.get('rank')
break
if mon_number is None:
rlogger.error("could not find '%s' in monmap", remote_hostname)
return False
if not mon_number in mon_quorum:
rlogger.error("Not yet quorum for '%s'", host)
return False
for keytype in ["admin", "mds", "mgr", "osd", "rgw"]:
if not gatherkeys_missing(args, distro, rlogger, path_keytype_mon, keytype, dest_dir):
# We will return failure if we fail to gather any key
rlogger.error("Failed to return '%s' key from host %s", keytype, host)
return False
return True | [
"def",
"gatherkeys_with_mon",
"(",
"args",
",",
"host",
",",
"dest_dir",
")",
":",
"distro",
"=",
"hosts",
".",
"get",
"(",
"host",
",",
"username",
"=",
"args",
".",
"username",
")",
"remote_hostname",
"=",
"distro",
".",
"conn",
".",
"remote_module",
".",
"shortname",
"(",
")",
"dir_keytype_mon",
"=",
"ceph_deploy",
".",
"util",
".",
"paths",
".",
"mon",
".",
"path",
"(",
"args",
".",
"cluster",
",",
"remote_hostname",
")",
"path_keytype_mon",
"=",
"\"%s/keyring\"",
"%",
"(",
"dir_keytype_mon",
")",
"mon_key",
"=",
"distro",
".",
"conn",
".",
"remote_module",
".",
"get_file",
"(",
"path_keytype_mon",
")",
"if",
"mon_key",
"is",
"None",
":",
"LOG",
".",
"warning",
"(",
"\"No mon key found in host: %s\"",
",",
"host",
")",
"return",
"False",
"mon_name_local",
"=",
"keytype_path_to",
"(",
"args",
",",
"\"mon\"",
")",
"mon_path_local",
"=",
"os",
".",
"path",
".",
"join",
"(",
"dest_dir",
",",
"mon_name_local",
")",
"with",
"open",
"(",
"mon_path_local",
",",
"'wb'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"mon_key",
")",
"rlogger",
"=",
"logging",
".",
"getLogger",
"(",
"host",
")",
"path_asok",
"=",
"ceph_deploy",
".",
"util",
".",
"paths",
".",
"mon",
".",
"asok",
"(",
"args",
".",
"cluster",
",",
"remote_hostname",
")",
"out",
",",
"err",
",",
"code",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"distro",
".",
"conn",
",",
"[",
"\"/usr/bin/ceph\"",
",",
"\"--connect-timeout=25\"",
",",
"\"--cluster={cluster}\"",
".",
"format",
"(",
"cluster",
"=",
"args",
".",
"cluster",
")",
",",
"\"--admin-daemon={asok}\"",
".",
"format",
"(",
"asok",
"=",
"path_asok",
")",
",",
"\"mon_status\"",
"]",
")",
"if",
"code",
"!=",
"0",
":",
"rlogger",
".",
"error",
"(",
"'\"ceph mon_status %s\" returned %s'",
",",
"host",
",",
"code",
")",
"for",
"line",
"in",
"err",
":",
"rlogger",
".",
"debug",
"(",
"line",
")",
"return",
"False",
"try",
":",
"mon_status",
"=",
"json",
".",
"loads",
"(",
"b''",
".",
"join",
"(",
"out",
")",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"except",
"ValueError",
":",
"rlogger",
".",
"error",
"(",
"'\"ceph mon_status %s\" output was not json'",
",",
"host",
")",
"for",
"line",
"in",
"out",
":",
"rlogger",
".",
"error",
"(",
"line",
")",
"return",
"False",
"mon_number",
"=",
"None",
"mon_map",
"=",
"mon_status",
".",
"get",
"(",
"'monmap'",
")",
"if",
"mon_map",
"is",
"None",
":",
"rlogger",
".",
"error",
"(",
"\"could not find mon map for mons on '%s'\"",
",",
"host",
")",
"return",
"False",
"mon_quorum",
"=",
"mon_status",
".",
"get",
"(",
"'quorum'",
")",
"if",
"mon_quorum",
"is",
"None",
":",
"rlogger",
".",
"error",
"(",
"\"could not find quorum for mons on '%s'\"",
",",
"host",
")",
"return",
"False",
"mon_map_mons",
"=",
"mon_map",
".",
"get",
"(",
"'mons'",
")",
"if",
"mon_map_mons",
"is",
"None",
":",
"rlogger",
".",
"error",
"(",
"\"could not find mons in monmap on '%s'\"",
",",
"host",
")",
"return",
"False",
"for",
"mon",
"in",
"mon_map_mons",
":",
"if",
"mon",
".",
"get",
"(",
"'name'",
")",
"==",
"remote_hostname",
":",
"mon_number",
"=",
"mon",
".",
"get",
"(",
"'rank'",
")",
"break",
"if",
"mon_number",
"is",
"None",
":",
"rlogger",
".",
"error",
"(",
"\"could not find '%s' in monmap\"",
",",
"remote_hostname",
")",
"return",
"False",
"if",
"not",
"mon_number",
"in",
"mon_quorum",
":",
"rlogger",
".",
"error",
"(",
"\"Not yet quorum for '%s'\"",
",",
"host",
")",
"return",
"False",
"for",
"keytype",
"in",
"[",
"\"admin\"",
",",
"\"mds\"",
",",
"\"mgr\"",
",",
"\"osd\"",
",",
"\"rgw\"",
"]",
":",
"if",
"not",
"gatherkeys_missing",
"(",
"args",
",",
"distro",
",",
"rlogger",
",",
"path_keytype_mon",
",",
"keytype",
",",
"dest_dir",
")",
":",
"# We will return failure if we fail to gather any key",
"rlogger",
".",
"error",
"(",
"\"Failed to return '%s' key from host %s\"",
",",
"keytype",
",",
"host",
")",
"return",
"False",
"return",
"True"
] | Connect to mon and gather keys if mon is in quorum. | [
"Connect",
"to",
"mon",
"and",
"gather",
"keys",
"if",
"mon",
"is",
"in",
"quorum",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L150-L220 |
247,244 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | gatherkeys | def gatherkeys(args):
"""
Gather keys from any mon and store in current working directory.
Backs up keys from previous installs and stores new keys.
"""
oldmask = os.umask(0o77)
try:
try:
tmpd = tempfile.mkdtemp()
LOG.info("Storing keys in temp directory %s", tmpd)
sucess = False
for host in args.mon:
sucess = gatherkeys_with_mon(args, host, tmpd)
if sucess:
break
if not sucess:
LOG.error("Failed to connect to host:%s" ,', '.join(args.mon))
raise RuntimeError('Failed to connect any mon')
had_error = False
date_string = time.strftime("%Y%m%d%H%M%S")
for keytype in ["admin", "mds", "mgr", "mon", "osd", "rgw"]:
filename = keytype_path_to(args, keytype)
tmp_path = os.path.join(tmpd, filename)
if not os.path.exists(tmp_path):
LOG.error("No key retrived for '%s'" , keytype)
had_error = True
continue
if not os.path.exists(filename):
LOG.info("Storing %s" % (filename))
shutil.move(tmp_path, filename)
continue
if _keyring_equivalent(tmp_path, filename):
LOG.info("keyring '%s' already exists" , filename)
continue
backup_keyring = "%s-%s" % (filename, date_string)
LOG.info("Replacing '%s' and backing up old key as '%s'", filename, backup_keyring)
shutil.copy(filename, backup_keyring)
shutil.move(tmp_path, filename)
if had_error:
raise RuntimeError('Failed to get all key types')
finally:
LOG.info("Destroy temp directory %s" %(tmpd))
shutil.rmtree(tmpd)
finally:
os.umask(oldmask) | python | def gatherkeys(args):
oldmask = os.umask(0o77)
try:
try:
tmpd = tempfile.mkdtemp()
LOG.info("Storing keys in temp directory %s", tmpd)
sucess = False
for host in args.mon:
sucess = gatherkeys_with_mon(args, host, tmpd)
if sucess:
break
if not sucess:
LOG.error("Failed to connect to host:%s" ,', '.join(args.mon))
raise RuntimeError('Failed to connect any mon')
had_error = False
date_string = time.strftime("%Y%m%d%H%M%S")
for keytype in ["admin", "mds", "mgr", "mon", "osd", "rgw"]:
filename = keytype_path_to(args, keytype)
tmp_path = os.path.join(tmpd, filename)
if not os.path.exists(tmp_path):
LOG.error("No key retrived for '%s'" , keytype)
had_error = True
continue
if not os.path.exists(filename):
LOG.info("Storing %s" % (filename))
shutil.move(tmp_path, filename)
continue
if _keyring_equivalent(tmp_path, filename):
LOG.info("keyring '%s' already exists" , filename)
continue
backup_keyring = "%s-%s" % (filename, date_string)
LOG.info("Replacing '%s' and backing up old key as '%s'", filename, backup_keyring)
shutil.copy(filename, backup_keyring)
shutil.move(tmp_path, filename)
if had_error:
raise RuntimeError('Failed to get all key types')
finally:
LOG.info("Destroy temp directory %s" %(tmpd))
shutil.rmtree(tmpd)
finally:
os.umask(oldmask) | [
"def",
"gatherkeys",
"(",
"args",
")",
":",
"oldmask",
"=",
"os",
".",
"umask",
"(",
"0o77",
")",
"try",
":",
"try",
":",
"tmpd",
"=",
"tempfile",
".",
"mkdtemp",
"(",
")",
"LOG",
".",
"info",
"(",
"\"Storing keys in temp directory %s\"",
",",
"tmpd",
")",
"sucess",
"=",
"False",
"for",
"host",
"in",
"args",
".",
"mon",
":",
"sucess",
"=",
"gatherkeys_with_mon",
"(",
"args",
",",
"host",
",",
"tmpd",
")",
"if",
"sucess",
":",
"break",
"if",
"not",
"sucess",
":",
"LOG",
".",
"error",
"(",
"\"Failed to connect to host:%s\"",
",",
"', '",
".",
"join",
"(",
"args",
".",
"mon",
")",
")",
"raise",
"RuntimeError",
"(",
"'Failed to connect any mon'",
")",
"had_error",
"=",
"False",
"date_string",
"=",
"time",
".",
"strftime",
"(",
"\"%Y%m%d%H%M%S\"",
")",
"for",
"keytype",
"in",
"[",
"\"admin\"",
",",
"\"mds\"",
",",
"\"mgr\"",
",",
"\"mon\"",
",",
"\"osd\"",
",",
"\"rgw\"",
"]",
":",
"filename",
"=",
"keytype_path_to",
"(",
"args",
",",
"keytype",
")",
"tmp_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"tmpd",
",",
"filename",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"tmp_path",
")",
":",
"LOG",
".",
"error",
"(",
"\"No key retrived for '%s'\"",
",",
"keytype",
")",
"had_error",
"=",
"True",
"continue",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"filename",
")",
":",
"LOG",
".",
"info",
"(",
"\"Storing %s\"",
"%",
"(",
"filename",
")",
")",
"shutil",
".",
"move",
"(",
"tmp_path",
",",
"filename",
")",
"continue",
"if",
"_keyring_equivalent",
"(",
"tmp_path",
",",
"filename",
")",
":",
"LOG",
".",
"info",
"(",
"\"keyring '%s' already exists\"",
",",
"filename",
")",
"continue",
"backup_keyring",
"=",
"\"%s-%s\"",
"%",
"(",
"filename",
",",
"date_string",
")",
"LOG",
".",
"info",
"(",
"\"Replacing '%s' and backing up old key as '%s'\"",
",",
"filename",
",",
"backup_keyring",
")",
"shutil",
".",
"copy",
"(",
"filename",
",",
"backup_keyring",
")",
"shutil",
".",
"move",
"(",
"tmp_path",
",",
"filename",
")",
"if",
"had_error",
":",
"raise",
"RuntimeError",
"(",
"'Failed to get all key types'",
")",
"finally",
":",
"LOG",
".",
"info",
"(",
"\"Destroy temp directory %s\"",
"%",
"(",
"tmpd",
")",
")",
"shutil",
".",
"rmtree",
"(",
"tmpd",
")",
"finally",
":",
"os",
".",
"umask",
"(",
"oldmask",
")"
] | Gather keys from any mon and store in current working directory.
Backs up keys from previous installs and stores new keys. | [
"Gather",
"keys",
"from",
"any",
"mon",
"and",
"store",
"in",
"current",
"working",
"directory",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L223-L268 |
247,245 | ceph/ceph-deploy | ceph_deploy/gatherkeys.py | make | def make(parser):
"""
Gather authentication keys for provisioning new nodes.
"""
parser.add_argument(
'mon',
metavar='HOST',
nargs='+',
help='monitor host to pull keys from',
)
parser.set_defaults(
func=gatherkeys,
) | python | def make(parser):
parser.add_argument(
'mon',
metavar='HOST',
nargs='+',
help='monitor host to pull keys from',
)
parser.set_defaults(
func=gatherkeys,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'mon'",
",",
"metavar",
"=",
"'HOST'",
",",
"nargs",
"=",
"'+'",
",",
"help",
"=",
"'monitor host to pull keys from'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"gatherkeys",
",",
")"
] | Gather authentication keys for provisioning new nodes. | [
"Gather",
"authentication",
"keys",
"for",
"provisioning",
"new",
"nodes",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/gatherkeys.py#L272-L284 |
247,246 | ceph/ceph-deploy | ceph_deploy/hosts/__init__.py | get | 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', 'alt']
module.is_deb = module.normalized_name in ['debian', 'ubuntu']
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 | python | def get(hostname,
username=None,
fallback=None,
detect_sudo=True,
use_rhceph=False,
callbacks=None):
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', 'alt']
module.is_deb = module.normalized_name in ['debian', 'ubuntu']
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",
"get",
"(",
"hostname",
",",
"username",
"=",
"None",
",",
"fallback",
"=",
"None",
",",
"detect_sudo",
"=",
"True",
",",
"use_rhceph",
"=",
"False",
",",
"callbacks",
"=",
"None",
")",
":",
"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'",
",",
"'alt'",
"]",
"module",
".",
"is_deb",
"=",
"module",
".",
"normalized_name",
"in",
"[",
"'debian'",
",",
"'ubuntu'",
"]",
"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"
] | 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. | [
"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",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/__init__.py#L16-L84 |
247,247 | ceph/ceph-deploy | ceph_deploy/connection.py | get_connection | def get_connection(hostname, username, logger, threads=5, use_sudo=None, detect_sudo=True):
"""
A very simple helper, meant to return a connection
that will know about the need to use sudo.
"""
if username:
hostname = "%s@%s" % (username, hostname)
try:
conn = remoto.Connection(
hostname,
logger=logger,
threads=threads,
detect_sudo=detect_sudo,
)
# Set a timeout value in seconds to disconnect and move on
# if no data is sent back.
conn.global_timeout = 300
logger.debug("connected to host: %s " % hostname)
return conn
except Exception as error:
msg = "connecting to host: %s " % hostname
errors = "resulted in errors: %s %s" % (error.__class__.__name__, error)
raise RuntimeError(msg + errors) | python | def get_connection(hostname, username, logger, threads=5, use_sudo=None, detect_sudo=True):
if username:
hostname = "%s@%s" % (username, hostname)
try:
conn = remoto.Connection(
hostname,
logger=logger,
threads=threads,
detect_sudo=detect_sudo,
)
# Set a timeout value in seconds to disconnect and move on
# if no data is sent back.
conn.global_timeout = 300
logger.debug("connected to host: %s " % hostname)
return conn
except Exception as error:
msg = "connecting to host: %s " % hostname
errors = "resulted in errors: %s %s" % (error.__class__.__name__, error)
raise RuntimeError(msg + errors) | [
"def",
"get_connection",
"(",
"hostname",
",",
"username",
",",
"logger",
",",
"threads",
"=",
"5",
",",
"use_sudo",
"=",
"None",
",",
"detect_sudo",
"=",
"True",
")",
":",
"if",
"username",
":",
"hostname",
"=",
"\"%s@%s\"",
"%",
"(",
"username",
",",
"hostname",
")",
"try",
":",
"conn",
"=",
"remoto",
".",
"Connection",
"(",
"hostname",
",",
"logger",
"=",
"logger",
",",
"threads",
"=",
"threads",
",",
"detect_sudo",
"=",
"detect_sudo",
",",
")",
"# Set a timeout value in seconds to disconnect and move on",
"# if no data is sent back.",
"conn",
".",
"global_timeout",
"=",
"300",
"logger",
".",
"debug",
"(",
"\"connected to host: %s \"",
"%",
"hostname",
")",
"return",
"conn",
"except",
"Exception",
"as",
"error",
":",
"msg",
"=",
"\"connecting to host: %s \"",
"%",
"hostname",
"errors",
"=",
"\"resulted in errors: %s %s\"",
"%",
"(",
"error",
".",
"__class__",
".",
"__name__",
",",
"error",
")",
"raise",
"RuntimeError",
"(",
"msg",
"+",
"errors",
")"
] | A very simple helper, meant to return a connection
that will know about the need to use sudo. | [
"A",
"very",
"simple",
"helper",
"meant",
"to",
"return",
"a",
"connection",
"that",
"will",
"know",
"about",
"the",
"need",
"to",
"use",
"sudo",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/connection.py#L5-L29 |
247,248 | ceph/ceph-deploy | ceph_deploy/connection.py | get_local_connection | def get_local_connection(logger, use_sudo=False):
"""
Helper for local connections that are sometimes needed to operate
on local hosts
"""
return get_connection(
socket.gethostname(), # cannot rely on 'localhost' here
None,
logger=logger,
threads=1,
use_sudo=use_sudo,
detect_sudo=False
) | python | def get_local_connection(logger, use_sudo=False):
return get_connection(
socket.gethostname(), # cannot rely on 'localhost' here
None,
logger=logger,
threads=1,
use_sudo=use_sudo,
detect_sudo=False
) | [
"def",
"get_local_connection",
"(",
"logger",
",",
"use_sudo",
"=",
"False",
")",
":",
"return",
"get_connection",
"(",
"socket",
".",
"gethostname",
"(",
")",
",",
"# cannot rely on 'localhost' here",
"None",
",",
"logger",
"=",
"logger",
",",
"threads",
"=",
"1",
",",
"use_sudo",
"=",
"use_sudo",
",",
"detect_sudo",
"=",
"False",
")"
] | Helper for local connections that are sometimes needed to operate
on local hosts | [
"Helper",
"for",
"local",
"connections",
"that",
"are",
"sometimes",
"needed",
"to",
"operate",
"on",
"local",
"hosts"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/connection.py#L32-L44 |
247,249 | ceph/ceph-deploy | ceph_deploy/mgr.py | make | def make(parser):
"""
Ceph MGR daemon management
"""
mgr_parser = parser.add_subparsers(dest='subcommand')
mgr_parser.required = True
mgr_create = mgr_parser.add_parser(
'create',
help='Deploy Ceph MGR on remote host(s)'
)
mgr_create.add_argument(
'mgr',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on',
)
parser.set_defaults(
func=mgr,
) | python | def make(parser):
mgr_parser = parser.add_subparsers(dest='subcommand')
mgr_parser.required = True
mgr_create = mgr_parser.add_parser(
'create',
help='Deploy Ceph MGR on remote host(s)'
)
mgr_create.add_argument(
'mgr',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on',
)
parser.set_defaults(
func=mgr,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"mgr_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"mgr_parser",
".",
"required",
"=",
"True",
"mgr_create",
"=",
"mgr_parser",
".",
"add_parser",
"(",
"'create'",
",",
"help",
"=",
"'Deploy Ceph MGR on remote host(s)'",
")",
"mgr_create",
".",
"add_argument",
"(",
"'mgr'",
",",
"metavar",
"=",
"'HOST[:NAME]'",
",",
"nargs",
"=",
"'+'",
",",
"type",
"=",
"colon_separated",
",",
"help",
"=",
"'host (and optionally the daemon name) to deploy on'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"mgr",
",",
")"
] | Ceph MGR daemon management | [
"Ceph",
"MGR",
"daemon",
"management"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/mgr.py#L206-L226 |
247,250 | ceph/ceph-deploy | ceph_deploy/pkg.py | make | def make(parser):
"""
Manage packages on remote hosts.
"""
action = parser.add_mutually_exclusive_group()
action.add_argument(
'--install',
metavar='PKG(s)',
help='Comma-separated package(s) to install',
)
action.add_argument(
'--remove',
metavar='PKG(s)',
help='Comma-separated package(s) to remove',
)
parser.add_argument(
'hosts',
nargs='+',
)
parser.set_defaults(
func=pkg,
) | python | def make(parser):
action = parser.add_mutually_exclusive_group()
action.add_argument(
'--install',
metavar='PKG(s)',
help='Comma-separated package(s) to install',
)
action.add_argument(
'--remove',
metavar='PKG(s)',
help='Comma-separated package(s) to remove',
)
parser.add_argument(
'hosts',
nargs='+',
)
parser.set_defaults(
func=pkg,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"action",
"=",
"parser",
".",
"add_mutually_exclusive_group",
"(",
")",
"action",
".",
"add_argument",
"(",
"'--install'",
",",
"metavar",
"=",
"'PKG(s)'",
",",
"help",
"=",
"'Comma-separated package(s) to install'",
",",
")",
"action",
".",
"add_argument",
"(",
"'--remove'",
",",
"metavar",
"=",
"'PKG(s)'",
",",
"help",
"=",
"'Comma-separated package(s) to remove'",
",",
")",
"parser",
".",
"add_argument",
"(",
"'hosts'",
",",
"nargs",
"=",
"'+'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"pkg",
",",
")"
] | Manage packages on remote hosts. | [
"Manage",
"packages",
"on",
"remote",
"hosts",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/pkg.py#L60-L86 |
247,251 | ceph/ceph-deploy | ceph_deploy/osd.py | get_bootstrap_osd_key | def get_bootstrap_osd_key(cluster):
"""
Read the bootstrap-osd key for `cluster`.
"""
path = '{cluster}.bootstrap-osd.keyring'.format(cluster=cluster)
try:
with open(path, 'rb') as f:
return f.read()
except IOError:
raise RuntimeError('bootstrap-osd keyring not found; run \'gatherkeys\'') | python | def get_bootstrap_osd_key(cluster):
path = '{cluster}.bootstrap-osd.keyring'.format(cluster=cluster)
try:
with open(path, 'rb') as f:
return f.read()
except IOError:
raise RuntimeError('bootstrap-osd keyring not found; run \'gatherkeys\'') | [
"def",
"get_bootstrap_osd_key",
"(",
"cluster",
")",
":",
"path",
"=",
"'{cluster}.bootstrap-osd.keyring'",
".",
"format",
"(",
"cluster",
"=",
"cluster",
")",
"try",
":",
"with",
"open",
"(",
"path",
",",
"'rb'",
")",
"as",
"f",
":",
"return",
"f",
".",
"read",
"(",
")",
"except",
"IOError",
":",
"raise",
"RuntimeError",
"(",
"'bootstrap-osd keyring not found; run \\'gatherkeys\\''",
")"
] | Read the bootstrap-osd key for `cluster`. | [
"Read",
"the",
"bootstrap",
"-",
"osd",
"key",
"for",
"cluster",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L17-L26 |
247,252 | ceph/ceph-deploy | ceph_deploy/osd.py | create_osd_keyring | def create_osd_keyring(conn, cluster, key):
"""
Run on osd node, writes the bootstrap key if not there yet.
"""
logger = conn.logger
path = '/var/lib/ceph/bootstrap-osd/{cluster}.keyring'.format(
cluster=cluster,
)
if not conn.remote_module.path_exists(path):
logger.warning('osd keyring does not exist yet, creating one')
conn.remote_module.write_keyring(path, key) | python | def create_osd_keyring(conn, cluster, key):
logger = conn.logger
path = '/var/lib/ceph/bootstrap-osd/{cluster}.keyring'.format(
cluster=cluster,
)
if not conn.remote_module.path_exists(path):
logger.warning('osd keyring does not exist yet, creating one')
conn.remote_module.write_keyring(path, key) | [
"def",
"create_osd_keyring",
"(",
"conn",
",",
"cluster",
",",
"key",
")",
":",
"logger",
"=",
"conn",
".",
"logger",
"path",
"=",
"'/var/lib/ceph/bootstrap-osd/{cluster}.keyring'",
".",
"format",
"(",
"cluster",
"=",
"cluster",
",",
")",
"if",
"not",
"conn",
".",
"remote_module",
".",
"path_exists",
"(",
"path",
")",
":",
"logger",
".",
"warning",
"(",
"'osd keyring does not exist yet, creating one'",
")",
"conn",
".",
"remote_module",
".",
"write_keyring",
"(",
"path",
",",
"key",
")"
] | Run on osd node, writes the bootstrap key if not there yet. | [
"Run",
"on",
"osd",
"node",
"writes",
"the",
"bootstrap",
"key",
"if",
"not",
"there",
"yet",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L29-L39 |
247,253 | ceph/ceph-deploy | ceph_deploy/osd.py | osd_tree | def osd_tree(conn, cluster):
"""
Check the status of an OSD. Make sure all are up and in
What good output would look like::
{
"epoch": 8,
"num_osds": 1,
"num_up_osds": 1,
"num_in_osds": "1",
"full": "false",
"nearfull": "false"
}
Note how the booleans are actually strings, so we need to take that into
account and fix it before returning the dictionary. Issue #8108
"""
ceph_executable = system.executable_path(conn, 'ceph')
command = [
ceph_executable,
'--cluster={cluster}'.format(cluster=cluster),
'osd',
'tree',
'--format=json',
]
out, err, code = remoto.process.check(
conn,
command,
)
try:
loaded_json = json.loads(b''.join(out).decode('utf-8'))
# convert boolean strings to actual booleans because
# --format=json fails to do this properly
for k, v in loaded_json.items():
if v == 'true':
loaded_json[k] = True
elif v == 'false':
loaded_json[k] = False
return loaded_json
except ValueError:
return {} | python | def osd_tree(conn, cluster):
ceph_executable = system.executable_path(conn, 'ceph')
command = [
ceph_executable,
'--cluster={cluster}'.format(cluster=cluster),
'osd',
'tree',
'--format=json',
]
out, err, code = remoto.process.check(
conn,
command,
)
try:
loaded_json = json.loads(b''.join(out).decode('utf-8'))
# convert boolean strings to actual booleans because
# --format=json fails to do this properly
for k, v in loaded_json.items():
if v == 'true':
loaded_json[k] = True
elif v == 'false':
loaded_json[k] = False
return loaded_json
except ValueError:
return {} | [
"def",
"osd_tree",
"(",
"conn",
",",
"cluster",
")",
":",
"ceph_executable",
"=",
"system",
".",
"executable_path",
"(",
"conn",
",",
"'ceph'",
")",
"command",
"=",
"[",
"ceph_executable",
",",
"'--cluster={cluster}'",
".",
"format",
"(",
"cluster",
"=",
"cluster",
")",
",",
"'osd'",
",",
"'tree'",
",",
"'--format=json'",
",",
"]",
"out",
",",
"err",
",",
"code",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"conn",
",",
"command",
",",
")",
"try",
":",
"loaded_json",
"=",
"json",
".",
"loads",
"(",
"b''",
".",
"join",
"(",
"out",
")",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"# convert boolean strings to actual booleans because",
"# --format=json fails to do this properly",
"for",
"k",
",",
"v",
"in",
"loaded_json",
".",
"items",
"(",
")",
":",
"if",
"v",
"==",
"'true'",
":",
"loaded_json",
"[",
"k",
"]",
"=",
"True",
"elif",
"v",
"==",
"'false'",
":",
"loaded_json",
"[",
"k",
"]",
"=",
"False",
"return",
"loaded_json",
"except",
"ValueError",
":",
"return",
"{",
"}"
] | Check the status of an OSD. Make sure all are up and in
What good output would look like::
{
"epoch": 8,
"num_osds": 1,
"num_up_osds": 1,
"num_in_osds": "1",
"full": "false",
"nearfull": "false"
}
Note how the booleans are actually strings, so we need to take that into
account and fix it before returning the dictionary. Issue #8108 | [
"Check",
"the",
"status",
"of",
"an",
"OSD",
".",
"Make",
"sure",
"all",
"are",
"up",
"and",
"in"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L42-L85 |
247,254 | ceph/ceph-deploy | ceph_deploy/osd.py | catch_osd_errors | def catch_osd_errors(conn, logger, args):
"""
Look for possible issues when checking the status of an OSD and
report them back to the user.
"""
logger.info('checking OSD status...')
status = osd_status_check(conn, args.cluster)
osds = int(status.get('num_osds', 0))
up_osds = int(status.get('num_up_osds', 0))
in_osds = int(status.get('num_in_osds', 0))
full = status.get('full', False)
nearfull = status.get('nearfull', False)
if osds > up_osds:
difference = osds - up_osds
logger.warning('there %s %d OSD%s down' % (
['is', 'are'][difference != 1],
difference,
"s"[difference == 1:])
)
if osds > in_osds:
difference = osds - in_osds
logger.warning('there %s %d OSD%s out' % (
['is', 'are'][difference != 1],
difference,
"s"[difference == 1:])
)
if full:
logger.warning('OSDs are full!')
if nearfull:
logger.warning('OSDs are near full!') | python | def catch_osd_errors(conn, logger, args):
logger.info('checking OSD status...')
status = osd_status_check(conn, args.cluster)
osds = int(status.get('num_osds', 0))
up_osds = int(status.get('num_up_osds', 0))
in_osds = int(status.get('num_in_osds', 0))
full = status.get('full', False)
nearfull = status.get('nearfull', False)
if osds > up_osds:
difference = osds - up_osds
logger.warning('there %s %d OSD%s down' % (
['is', 'are'][difference != 1],
difference,
"s"[difference == 1:])
)
if osds > in_osds:
difference = osds - in_osds
logger.warning('there %s %d OSD%s out' % (
['is', 'are'][difference != 1],
difference,
"s"[difference == 1:])
)
if full:
logger.warning('OSDs are full!')
if nearfull:
logger.warning('OSDs are near full!') | [
"def",
"catch_osd_errors",
"(",
"conn",
",",
"logger",
",",
"args",
")",
":",
"logger",
".",
"info",
"(",
"'checking OSD status...'",
")",
"status",
"=",
"osd_status_check",
"(",
"conn",
",",
"args",
".",
"cluster",
")",
"osds",
"=",
"int",
"(",
"status",
".",
"get",
"(",
"'num_osds'",
",",
"0",
")",
")",
"up_osds",
"=",
"int",
"(",
"status",
".",
"get",
"(",
"'num_up_osds'",
",",
"0",
")",
")",
"in_osds",
"=",
"int",
"(",
"status",
".",
"get",
"(",
"'num_in_osds'",
",",
"0",
")",
")",
"full",
"=",
"status",
".",
"get",
"(",
"'full'",
",",
"False",
")",
"nearfull",
"=",
"status",
".",
"get",
"(",
"'nearfull'",
",",
"False",
")",
"if",
"osds",
">",
"up_osds",
":",
"difference",
"=",
"osds",
"-",
"up_osds",
"logger",
".",
"warning",
"(",
"'there %s %d OSD%s down'",
"%",
"(",
"[",
"'is'",
",",
"'are'",
"]",
"[",
"difference",
"!=",
"1",
"]",
",",
"difference",
",",
"\"s\"",
"[",
"difference",
"==",
"1",
":",
"]",
")",
")",
"if",
"osds",
">",
"in_osds",
":",
"difference",
"=",
"osds",
"-",
"in_osds",
"logger",
".",
"warning",
"(",
"'there %s %d OSD%s out'",
"%",
"(",
"[",
"'is'",
",",
"'are'",
"]",
"[",
"difference",
"!=",
"1",
"]",
",",
"difference",
",",
"\"s\"",
"[",
"difference",
"==",
"1",
":",
"]",
")",
")",
"if",
"full",
":",
"logger",
".",
"warning",
"(",
"'OSDs are full!'",
")",
"if",
"nearfull",
":",
"logger",
".",
"warning",
"(",
"'OSDs are near full!'",
")"
] | Look for possible issues when checking the status of an OSD and
report them back to the user. | [
"Look",
"for",
"possible",
"issues",
"when",
"checking",
"the",
"status",
"of",
"an",
"OSD",
"and",
"report",
"them",
"back",
"to",
"the",
"user",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L141-L174 |
247,255 | ceph/ceph-deploy | ceph_deploy/osd.py | create_osd | def create_osd(
conn,
cluster,
data,
journal,
zap,
fs_type,
dmcrypt,
dmcrypt_dir,
storetype,
block_wal,
block_db,
**kw):
"""
Run on osd node, creates an OSD from a data disk.
"""
ceph_volume_executable = system.executable_path(conn, 'ceph-volume')
args = [
ceph_volume_executable,
'--cluster', cluster,
'lvm',
'create',
'--%s' % storetype,
'--data', data
]
if zap:
LOG.warning('zapping is no longer supported when preparing')
if dmcrypt:
args.append('--dmcrypt')
# TODO: re-enable dmcrypt support once ceph-volume grows it
LOG.warning('dmcrypt is currently not supported')
if storetype == 'bluestore':
if block_wal:
args.append('--block.wal')
args.append(block_wal)
if block_db:
args.append('--block.db')
args.append(block_db)
elif storetype == 'filestore':
if not journal:
raise RuntimeError('A journal lv or GPT partition must be specified when using filestore')
args.append('--journal')
args.append(journal)
if kw.get('debug'):
remoto.process.run(
conn,
args,
extend_env={'CEPH_VOLUME_DEBUG': '1'}
)
else:
remoto.process.run(
conn,
args
) | python | def create_osd(
conn,
cluster,
data,
journal,
zap,
fs_type,
dmcrypt,
dmcrypt_dir,
storetype,
block_wal,
block_db,
**kw):
ceph_volume_executable = system.executable_path(conn, 'ceph-volume')
args = [
ceph_volume_executable,
'--cluster', cluster,
'lvm',
'create',
'--%s' % storetype,
'--data', data
]
if zap:
LOG.warning('zapping is no longer supported when preparing')
if dmcrypt:
args.append('--dmcrypt')
# TODO: re-enable dmcrypt support once ceph-volume grows it
LOG.warning('dmcrypt is currently not supported')
if storetype == 'bluestore':
if block_wal:
args.append('--block.wal')
args.append(block_wal)
if block_db:
args.append('--block.db')
args.append(block_db)
elif storetype == 'filestore':
if not journal:
raise RuntimeError('A journal lv or GPT partition must be specified when using filestore')
args.append('--journal')
args.append(journal)
if kw.get('debug'):
remoto.process.run(
conn,
args,
extend_env={'CEPH_VOLUME_DEBUG': '1'}
)
else:
remoto.process.run(
conn,
args
) | [
"def",
"create_osd",
"(",
"conn",
",",
"cluster",
",",
"data",
",",
"journal",
",",
"zap",
",",
"fs_type",
",",
"dmcrypt",
",",
"dmcrypt_dir",
",",
"storetype",
",",
"block_wal",
",",
"block_db",
",",
"*",
"*",
"kw",
")",
":",
"ceph_volume_executable",
"=",
"system",
".",
"executable_path",
"(",
"conn",
",",
"'ceph-volume'",
")",
"args",
"=",
"[",
"ceph_volume_executable",
",",
"'--cluster'",
",",
"cluster",
",",
"'lvm'",
",",
"'create'",
",",
"'--%s'",
"%",
"storetype",
",",
"'--data'",
",",
"data",
"]",
"if",
"zap",
":",
"LOG",
".",
"warning",
"(",
"'zapping is no longer supported when preparing'",
")",
"if",
"dmcrypt",
":",
"args",
".",
"append",
"(",
"'--dmcrypt'",
")",
"# TODO: re-enable dmcrypt support once ceph-volume grows it",
"LOG",
".",
"warning",
"(",
"'dmcrypt is currently not supported'",
")",
"if",
"storetype",
"==",
"'bluestore'",
":",
"if",
"block_wal",
":",
"args",
".",
"append",
"(",
"'--block.wal'",
")",
"args",
".",
"append",
"(",
"block_wal",
")",
"if",
"block_db",
":",
"args",
".",
"append",
"(",
"'--block.db'",
")",
"args",
".",
"append",
"(",
"block_db",
")",
"elif",
"storetype",
"==",
"'filestore'",
":",
"if",
"not",
"journal",
":",
"raise",
"RuntimeError",
"(",
"'A journal lv or GPT partition must be specified when using filestore'",
")",
"args",
".",
"append",
"(",
"'--journal'",
")",
"args",
".",
"append",
"(",
"journal",
")",
"if",
"kw",
".",
"get",
"(",
"'debug'",
")",
":",
"remoto",
".",
"process",
".",
"run",
"(",
"conn",
",",
"args",
",",
"extend_env",
"=",
"{",
"'CEPH_VOLUME_DEBUG'",
":",
"'1'",
"}",
")",
"else",
":",
"remoto",
".",
"process",
".",
"run",
"(",
"conn",
",",
"args",
")"
] | Run on osd node, creates an OSD from a data disk. | [
"Run",
"on",
"osd",
"node",
"creates",
"an",
"OSD",
"from",
"a",
"data",
"disk",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L177-L233 |
247,256 | ceph/ceph-deploy | ceph_deploy/osd.py | make | def make(parser):
"""
Prepare a data disk on remote host.
"""
sub_command_help = dedent("""
Create OSDs from a data disk on a remote host:
ceph-deploy osd create {node} --data /path/to/device
For bluestore, optional devices can be used::
ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device
ceph-deploy osd create {node} --data /path/to/data --block-wal /path/to/wal-device
ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device --block-wal /path/to/wal-device
For filestore, the journal must be specified, as well as the objectstore::
ceph-deploy osd create {node} --filestore --data /path/to/data --journal /path/to/journal
For data devices, it can be an existing logical volume in the format of:
vg/lv, or a device. For other OSD components like wal, db, and journal, it
can be logical volume (in vg/lv format) or it must be a GPT partition.
"""
)
parser.formatter_class = argparse.RawDescriptionHelpFormatter
parser.description = sub_command_help
osd_parser = parser.add_subparsers(dest='subcommand')
osd_parser.required = True
osd_list = osd_parser.add_parser(
'list',
help='List OSD info from remote host(s)'
)
osd_list.add_argument(
'host',
nargs='+',
metavar='HOST',
help='remote host(s) to list OSDs from'
)
osd_list.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
osd_create = osd_parser.add_parser(
'create',
help='Create new Ceph OSD daemon by preparing and activating a device'
)
osd_create.add_argument(
'--data',
metavar='DATA',
help='The OSD data logical volume (vg/lv) or absolute path to device'
)
osd_create.add_argument(
'--journal',
help='Logical Volume (vg/lv) or path to GPT partition',
)
osd_create.add_argument(
'--zap-disk',
action='store_true',
help='DEPRECATED - cannot zap when creating an OSD'
)
osd_create.add_argument(
'--fs-type',
metavar='FS_TYPE',
choices=['xfs',
'btrfs'
],
default='xfs',
help='filesystem to use to format DEVICE (xfs, btrfs)',
)
osd_create.add_argument(
'--dmcrypt',
action='store_true',
help='use dm-crypt on DEVICE',
)
osd_create.add_argument(
'--dmcrypt-key-dir',
metavar='KEYDIR',
default='/etc/ceph/dmcrypt-keys',
help='directory where dm-crypt keys are stored',
)
osd_create.add_argument(
'--filestore',
action='store_true', default=None,
help='filestore objectstore',
)
osd_create.add_argument(
'--bluestore',
action='store_true', default=None,
help='bluestore objectstore',
)
osd_create.add_argument(
'--block-db',
default=None,
help='bluestore block.db path'
)
osd_create.add_argument(
'--block-wal',
default=None,
help='bluestore block.wal path'
)
osd_create.add_argument(
'host',
nargs='?',
metavar='HOST',
help='Remote host to connect'
)
osd_create.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
parser.set_defaults(
func=osd,
) | python | def make(parser):
sub_command_help = dedent("""
Create OSDs from a data disk on a remote host:
ceph-deploy osd create {node} --data /path/to/device
For bluestore, optional devices can be used::
ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device
ceph-deploy osd create {node} --data /path/to/data --block-wal /path/to/wal-device
ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device --block-wal /path/to/wal-device
For filestore, the journal must be specified, as well as the objectstore::
ceph-deploy osd create {node} --filestore --data /path/to/data --journal /path/to/journal
For data devices, it can be an existing logical volume in the format of:
vg/lv, or a device. For other OSD components like wal, db, and journal, it
can be logical volume (in vg/lv format) or it must be a GPT partition.
"""
)
parser.formatter_class = argparse.RawDescriptionHelpFormatter
parser.description = sub_command_help
osd_parser = parser.add_subparsers(dest='subcommand')
osd_parser.required = True
osd_list = osd_parser.add_parser(
'list',
help='List OSD info from remote host(s)'
)
osd_list.add_argument(
'host',
nargs='+',
metavar='HOST',
help='remote host(s) to list OSDs from'
)
osd_list.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
osd_create = osd_parser.add_parser(
'create',
help='Create new Ceph OSD daemon by preparing and activating a device'
)
osd_create.add_argument(
'--data',
metavar='DATA',
help='The OSD data logical volume (vg/lv) or absolute path to device'
)
osd_create.add_argument(
'--journal',
help='Logical Volume (vg/lv) or path to GPT partition',
)
osd_create.add_argument(
'--zap-disk',
action='store_true',
help='DEPRECATED - cannot zap when creating an OSD'
)
osd_create.add_argument(
'--fs-type',
metavar='FS_TYPE',
choices=['xfs',
'btrfs'
],
default='xfs',
help='filesystem to use to format DEVICE (xfs, btrfs)',
)
osd_create.add_argument(
'--dmcrypt',
action='store_true',
help='use dm-crypt on DEVICE',
)
osd_create.add_argument(
'--dmcrypt-key-dir',
metavar='KEYDIR',
default='/etc/ceph/dmcrypt-keys',
help='directory where dm-crypt keys are stored',
)
osd_create.add_argument(
'--filestore',
action='store_true', default=None,
help='filestore objectstore',
)
osd_create.add_argument(
'--bluestore',
action='store_true', default=None,
help='bluestore objectstore',
)
osd_create.add_argument(
'--block-db',
default=None,
help='bluestore block.db path'
)
osd_create.add_argument(
'--block-wal',
default=None,
help='bluestore block.wal path'
)
osd_create.add_argument(
'host',
nargs='?',
metavar='HOST',
help='Remote host to connect'
)
osd_create.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
parser.set_defaults(
func=osd,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"sub_command_help",
"=",
"dedent",
"(",
"\"\"\"\n Create OSDs from a data disk on a remote host:\n\n ceph-deploy osd create {node} --data /path/to/device\n\n For bluestore, optional devices can be used::\n\n ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device\n ceph-deploy osd create {node} --data /path/to/data --block-wal /path/to/wal-device\n ceph-deploy osd create {node} --data /path/to/data --block-db /path/to/db-device --block-wal /path/to/wal-device\n\n For filestore, the journal must be specified, as well as the objectstore::\n\n ceph-deploy osd create {node} --filestore --data /path/to/data --journal /path/to/journal\n\n For data devices, it can be an existing logical volume in the format of:\n vg/lv, or a device. For other OSD components like wal, db, and journal, it\n can be logical volume (in vg/lv format) or it must be a GPT partition.\n \"\"\"",
")",
"parser",
".",
"formatter_class",
"=",
"argparse",
".",
"RawDescriptionHelpFormatter",
"parser",
".",
"description",
"=",
"sub_command_help",
"osd_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"osd_parser",
".",
"required",
"=",
"True",
"osd_list",
"=",
"osd_parser",
".",
"add_parser",
"(",
"'list'",
",",
"help",
"=",
"'List OSD info from remote host(s)'",
")",
"osd_list",
".",
"add_argument",
"(",
"'host'",
",",
"nargs",
"=",
"'+'",
",",
"metavar",
"=",
"'HOST'",
",",
"help",
"=",
"'remote host(s) to list OSDs from'",
")",
"osd_list",
".",
"add_argument",
"(",
"'--debug'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'Enable debug mode on remote ceph-volume calls'",
",",
")",
"osd_create",
"=",
"osd_parser",
".",
"add_parser",
"(",
"'create'",
",",
"help",
"=",
"'Create new Ceph OSD daemon by preparing and activating a device'",
")",
"osd_create",
".",
"add_argument",
"(",
"'--data'",
",",
"metavar",
"=",
"'DATA'",
",",
"help",
"=",
"'The OSD data logical volume (vg/lv) or absolute path to device'",
")",
"osd_create",
".",
"add_argument",
"(",
"'--journal'",
",",
"help",
"=",
"'Logical Volume (vg/lv) or path to GPT partition'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--zap-disk'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'DEPRECATED - cannot zap when creating an OSD'",
")",
"osd_create",
".",
"add_argument",
"(",
"'--fs-type'",
",",
"metavar",
"=",
"'FS_TYPE'",
",",
"choices",
"=",
"[",
"'xfs'",
",",
"'btrfs'",
"]",
",",
"default",
"=",
"'xfs'",
",",
"help",
"=",
"'filesystem to use to format DEVICE (xfs, btrfs)'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--dmcrypt'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'use dm-crypt on DEVICE'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--dmcrypt-key-dir'",
",",
"metavar",
"=",
"'KEYDIR'",
",",
"default",
"=",
"'/etc/ceph/dmcrypt-keys'",
",",
"help",
"=",
"'directory where dm-crypt keys are stored'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--filestore'",
",",
"action",
"=",
"'store_true'",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'filestore objectstore'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--bluestore'",
",",
"action",
"=",
"'store_true'",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'bluestore objectstore'",
",",
")",
"osd_create",
".",
"add_argument",
"(",
"'--block-db'",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'bluestore block.db path'",
")",
"osd_create",
".",
"add_argument",
"(",
"'--block-wal'",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'bluestore block.wal path'",
")",
"osd_create",
".",
"add_argument",
"(",
"'host'",
",",
"nargs",
"=",
"'?'",
",",
"metavar",
"=",
"'HOST'",
",",
"help",
"=",
"'Remote host to connect'",
")",
"osd_create",
".",
"add_argument",
"(",
"'--debug'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'Enable debug mode on remote ceph-volume calls'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"osd",
",",
")"
] | Prepare a data disk on remote host. | [
"Prepare",
"a",
"data",
"disk",
"on",
"remote",
"host",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L445-L561 |
247,257 | ceph/ceph-deploy | ceph_deploy/osd.py | make_disk | def make_disk(parser):
"""
Manage disks on a remote host.
"""
disk_parser = parser.add_subparsers(dest='subcommand')
disk_parser.required = True
disk_zap = disk_parser.add_parser(
'zap',
help='destroy existing data and filesystem on LV or partition',
)
disk_zap.add_argument(
'host',
nargs='?',
metavar='HOST',
help='Remote HOST(s) to connect'
)
disk_zap.add_argument(
'disk',
nargs='+',
metavar='DISK',
help='Disk(s) to zap'
)
disk_zap.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
disk_list = disk_parser.add_parser(
'list',
help='List disk info from remote host(s)'
)
disk_list.add_argument(
'host',
nargs='+',
metavar='HOST',
help='Remote HOST(s) to list OSDs from'
)
disk_list.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
parser.set_defaults(
func=disk,
) | python | def make_disk(parser):
disk_parser = parser.add_subparsers(dest='subcommand')
disk_parser.required = True
disk_zap = disk_parser.add_parser(
'zap',
help='destroy existing data and filesystem on LV or partition',
)
disk_zap.add_argument(
'host',
nargs='?',
metavar='HOST',
help='Remote HOST(s) to connect'
)
disk_zap.add_argument(
'disk',
nargs='+',
metavar='DISK',
help='Disk(s) to zap'
)
disk_zap.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
disk_list = disk_parser.add_parser(
'list',
help='List disk info from remote host(s)'
)
disk_list.add_argument(
'host',
nargs='+',
metavar='HOST',
help='Remote HOST(s) to list OSDs from'
)
disk_list.add_argument(
'--debug',
action='store_true',
help='Enable debug mode on remote ceph-volume calls',
)
parser.set_defaults(
func=disk,
) | [
"def",
"make_disk",
"(",
"parser",
")",
":",
"disk_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"disk_parser",
".",
"required",
"=",
"True",
"disk_zap",
"=",
"disk_parser",
".",
"add_parser",
"(",
"'zap'",
",",
"help",
"=",
"'destroy existing data and filesystem on LV or partition'",
",",
")",
"disk_zap",
".",
"add_argument",
"(",
"'host'",
",",
"nargs",
"=",
"'?'",
",",
"metavar",
"=",
"'HOST'",
",",
"help",
"=",
"'Remote HOST(s) to connect'",
")",
"disk_zap",
".",
"add_argument",
"(",
"'disk'",
",",
"nargs",
"=",
"'+'",
",",
"metavar",
"=",
"'DISK'",
",",
"help",
"=",
"'Disk(s) to zap'",
")",
"disk_zap",
".",
"add_argument",
"(",
"'--debug'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'Enable debug mode on remote ceph-volume calls'",
",",
")",
"disk_list",
"=",
"disk_parser",
".",
"add_parser",
"(",
"'list'",
",",
"help",
"=",
"'List disk info from remote host(s)'",
")",
"disk_list",
".",
"add_argument",
"(",
"'host'",
",",
"nargs",
"=",
"'+'",
",",
"metavar",
"=",
"'HOST'",
",",
"help",
"=",
"'Remote HOST(s) to list OSDs from'",
")",
"disk_list",
".",
"add_argument",
"(",
"'--debug'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'Enable debug mode on remote ceph-volume calls'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"disk",
",",
")"
] | Manage disks on a remote host. | [
"Manage",
"disks",
"on",
"a",
"remote",
"host",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/osd.py#L565-L610 |
247,258 | ceph/ceph-deploy | ceph_deploy/hosts/centos/install.py | repository_url_part | def repository_url_part(distro):
"""
Historically everything CentOS, RHEL, and Scientific has been mapped to
`el6` urls, but as we are adding repositories for `rhel`, the URLs should
map correctly to, say, `rhel6` or `rhel7`.
This function looks into the `distro` object and determines the right url
part for the given distro, falling back to `el6` when all else fails.
Specifically to work around the issue of CentOS vs RHEL::
>>> import platform
>>> platform.linux_distribution()
('Red Hat Enterprise Linux Server', '7.0', 'Maipo')
"""
if distro.normalized_release.int_major >= 6:
if distro.normalized_name == 'redhat':
return 'rhel' + distro.normalized_release.major
if distro.normalized_name in ['centos', 'scientific', 'oracle', 'virtuozzo']:
return 'el' + distro.normalized_release.major
return 'el6' | python | def repository_url_part(distro):
if distro.normalized_release.int_major >= 6:
if distro.normalized_name == 'redhat':
return 'rhel' + distro.normalized_release.major
if distro.normalized_name in ['centos', 'scientific', 'oracle', 'virtuozzo']:
return 'el' + distro.normalized_release.major
return 'el6' | [
"def",
"repository_url_part",
"(",
"distro",
")",
":",
"if",
"distro",
".",
"normalized_release",
".",
"int_major",
">=",
"6",
":",
"if",
"distro",
".",
"normalized_name",
"==",
"'redhat'",
":",
"return",
"'rhel'",
"+",
"distro",
".",
"normalized_release",
".",
"major",
"if",
"distro",
".",
"normalized_name",
"in",
"[",
"'centos'",
",",
"'scientific'",
",",
"'oracle'",
",",
"'virtuozzo'",
"]",
":",
"return",
"'el'",
"+",
"distro",
".",
"normalized_release",
".",
"major",
"return",
"'el6'"
] | Historically everything CentOS, RHEL, and Scientific has been mapped to
`el6` urls, but as we are adding repositories for `rhel`, the URLs should
map correctly to, say, `rhel6` or `rhel7`.
This function looks into the `distro` object and determines the right url
part for the given distro, falling back to `el6` when all else fails.
Specifically to work around the issue of CentOS vs RHEL::
>>> import platform
>>> platform.linux_distribution()
('Red Hat Enterprise Linux Server', '7.0', 'Maipo') | [
"Historically",
"everything",
"CentOS",
"RHEL",
"and",
"Scientific",
"has",
"been",
"mapped",
"to",
"el6",
"urls",
"but",
"as",
"we",
"are",
"adding",
"repositories",
"for",
"rhel",
"the",
"URLs",
"should",
"map",
"correctly",
"to",
"say",
"rhel6",
"or",
"rhel7",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/centos/install.py#L19-L41 |
247,259 | ceph/ceph-deploy | ceph_deploy/install.py | sanitize_args | def sanitize_args(args):
"""
args may need a bunch of logic to set proper defaults that argparse is
not well suited for.
"""
if args.release is None:
args.release = 'nautilus'
args.default_release = True
# XXX This whole dance is because --stable is getting deprecated
if args.stable is not None:
LOG.warning('the --stable flag is deprecated, use --release instead')
args.release = args.stable
# XXX Tango ends here.
return args | python | def sanitize_args(args):
if args.release is None:
args.release = 'nautilus'
args.default_release = True
# XXX This whole dance is because --stable is getting deprecated
if args.stable is not None:
LOG.warning('the --stable flag is deprecated, use --release instead')
args.release = args.stable
# XXX Tango ends here.
return args | [
"def",
"sanitize_args",
"(",
"args",
")",
":",
"if",
"args",
".",
"release",
"is",
"None",
":",
"args",
".",
"release",
"=",
"'nautilus'",
"args",
".",
"default_release",
"=",
"True",
"# XXX This whole dance is because --stable is getting deprecated",
"if",
"args",
".",
"stable",
"is",
"not",
"None",
":",
"LOG",
".",
"warning",
"(",
"'the --stable flag is deprecated, use --release instead'",
")",
"args",
".",
"release",
"=",
"args",
".",
"stable",
"# XXX Tango ends here.",
"return",
"args"
] | args may need a bunch of logic to set proper defaults that argparse is
not well suited for. | [
"args",
"may",
"need",
"a",
"bunch",
"of",
"logic",
"to",
"set",
"proper",
"defaults",
"that",
"argparse",
"is",
"not",
"well",
"suited",
"for",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/install.py#L14-L29 |
247,260 | ceph/ceph-deploy | ceph_deploy/install.py | should_use_custom_repo | def should_use_custom_repo(args, cd_conf, repo_url):
"""
A boolean to determine the logic needed to proceed with a custom repo
installation instead of cramming everything nect to the logic operator.
"""
if repo_url:
# repo_url signals a CLI override, return False immediately
return False
if cd_conf:
if cd_conf.has_repos:
has_valid_release = args.release in cd_conf.get_repos()
has_default_repo = cd_conf.get_default_repo()
if has_valid_release or has_default_repo:
return True
return False | python | def should_use_custom_repo(args, cd_conf, repo_url):
if repo_url:
# repo_url signals a CLI override, return False immediately
return False
if cd_conf:
if cd_conf.has_repos:
has_valid_release = args.release in cd_conf.get_repos()
has_default_repo = cd_conf.get_default_repo()
if has_valid_release or has_default_repo:
return True
return False | [
"def",
"should_use_custom_repo",
"(",
"args",
",",
"cd_conf",
",",
"repo_url",
")",
":",
"if",
"repo_url",
":",
"# repo_url signals a CLI override, return False immediately",
"return",
"False",
"if",
"cd_conf",
":",
"if",
"cd_conf",
".",
"has_repos",
":",
"has_valid_release",
"=",
"args",
".",
"release",
"in",
"cd_conf",
".",
"get_repos",
"(",
")",
"has_default_repo",
"=",
"cd_conf",
".",
"get_default_repo",
"(",
")",
"if",
"has_valid_release",
"or",
"has_default_repo",
":",
"return",
"True",
"return",
"False"
] | A boolean to determine the logic needed to proceed with a custom repo
installation instead of cramming everything nect to the logic operator. | [
"A",
"boolean",
"to",
"determine",
"the",
"logic",
"needed",
"to",
"proceed",
"with",
"a",
"custom",
"repo",
"installation",
"instead",
"of",
"cramming",
"everything",
"nect",
"to",
"the",
"logic",
"operator",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/install.py#L215-L229 |
247,261 | ceph/ceph-deploy | ceph_deploy/install.py | make_uninstall | def make_uninstall(parser):
"""
Remove Ceph packages from remote hosts.
"""
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='hosts to uninstall Ceph from',
)
parser.set_defaults(
func=uninstall,
) | python | def make_uninstall(parser):
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='hosts to uninstall Ceph from',
)
parser.set_defaults(
func=uninstall,
) | [
"def",
"make_uninstall",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'host'",
",",
"metavar",
"=",
"'HOST'",
",",
"nargs",
"=",
"'+'",
",",
"help",
"=",
"'hosts to uninstall Ceph from'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"uninstall",
",",
")"
] | Remove Ceph packages from remote hosts. | [
"Remove",
"Ceph",
"packages",
"from",
"remote",
"hosts",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/install.py#L626-L638 |
247,262 | ceph/ceph-deploy | ceph_deploy/install.py | make_purge | def make_purge(parser):
"""
Remove Ceph packages from remote hosts and purge all data.
"""
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='hosts to purge Ceph from',
)
parser.set_defaults(
func=purge,
) | python | def make_purge(parser):
parser.add_argument(
'host',
metavar='HOST',
nargs='+',
help='hosts to purge Ceph from',
)
parser.set_defaults(
func=purge,
) | [
"def",
"make_purge",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'host'",
",",
"metavar",
"=",
"'HOST'",
",",
"nargs",
"=",
"'+'",
",",
"help",
"=",
"'hosts to purge Ceph from'",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"purge",
",",
")"
] | Remove Ceph packages from remote hosts and purge all data. | [
"Remove",
"Ceph",
"packages",
"from",
"remote",
"hosts",
"and",
"purge",
"all",
"data",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/install.py#L642-L654 |
247,263 | ceph/ceph-deploy | ceph_deploy/rgw.py | make | def make(parser):
"""
Ceph RGW daemon management
"""
rgw_parser = parser.add_subparsers(dest='subcommand')
rgw_parser.required = True
rgw_create = rgw_parser.add_parser(
'create',
help='Create an RGW instance'
)
rgw_create.add_argument(
'rgw',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on. \
NAME is automatically prefixed with \'rgw.\'',
)
parser.set_defaults(
func=rgw,
) | python | def make(parser):
rgw_parser = parser.add_subparsers(dest='subcommand')
rgw_parser.required = True
rgw_create = rgw_parser.add_parser(
'create',
help='Create an RGW instance'
)
rgw_create.add_argument(
'rgw',
metavar='HOST[:NAME]',
nargs='+',
type=colon_separated,
help='host (and optionally the daemon name) to deploy on. \
NAME is automatically prefixed with \'rgw.\'',
)
parser.set_defaults(
func=rgw,
) | [
"def",
"make",
"(",
"parser",
")",
":",
"rgw_parser",
"=",
"parser",
".",
"add_subparsers",
"(",
"dest",
"=",
"'subcommand'",
")",
"rgw_parser",
".",
"required",
"=",
"True",
"rgw_create",
"=",
"rgw_parser",
".",
"add_parser",
"(",
"'create'",
",",
"help",
"=",
"'Create an RGW instance'",
")",
"rgw_create",
".",
"add_argument",
"(",
"'rgw'",
",",
"metavar",
"=",
"'HOST[:NAME]'",
",",
"nargs",
"=",
"'+'",
",",
"type",
"=",
"colon_separated",
",",
"help",
"=",
"'host (and optionally the daemon name) to deploy on. \\\n NAME is automatically prefixed with \\'rgw.\\''",
",",
")",
"parser",
".",
"set_defaults",
"(",
"func",
"=",
"rgw",
",",
")"
] | Ceph RGW daemon management | [
"Ceph",
"RGW",
"daemon",
"management"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/rgw.py#L213-L233 |
247,264 | ceph/ceph-deploy | ceph_deploy/util/ssh.py | can_connect_passwordless | def can_connect_passwordless(hostname):
"""
Ensure that current host can SSH remotely to the remote
host using the ``BatchMode`` option to prevent a password prompt.
That attempt will error with an exit status of 255 and a ``Permission
denied`` message or a``Host key verification failed`` message.
"""
# Ensure we are not doing this for local hosts
if not remoto.backends.needs_ssh(hostname):
return True
logger = logging.getLogger(hostname)
with get_local_connection(logger) as conn:
# Check to see if we can login, disabling password prompts
command = ['ssh', '-CT', '-o', 'BatchMode=yes', hostname, 'true']
out, err, retval = remoto.process.check(conn, command, stop_on_error=False)
permission_denied_error = 'Permission denied '
host_key_verify_error = 'Host key verification failed.'
has_key_error = False
for line in err:
if permission_denied_error in line or host_key_verify_error in line:
has_key_error = True
if retval == 255 and has_key_error:
return False
return True | python | def can_connect_passwordless(hostname):
# Ensure we are not doing this for local hosts
if not remoto.backends.needs_ssh(hostname):
return True
logger = logging.getLogger(hostname)
with get_local_connection(logger) as conn:
# Check to see if we can login, disabling password prompts
command = ['ssh', '-CT', '-o', 'BatchMode=yes', hostname, 'true']
out, err, retval = remoto.process.check(conn, command, stop_on_error=False)
permission_denied_error = 'Permission denied '
host_key_verify_error = 'Host key verification failed.'
has_key_error = False
for line in err:
if permission_denied_error in line or host_key_verify_error in line:
has_key_error = True
if retval == 255 and has_key_error:
return False
return True | [
"def",
"can_connect_passwordless",
"(",
"hostname",
")",
":",
"# Ensure we are not doing this for local hosts",
"if",
"not",
"remoto",
".",
"backends",
".",
"needs_ssh",
"(",
"hostname",
")",
":",
"return",
"True",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"hostname",
")",
"with",
"get_local_connection",
"(",
"logger",
")",
"as",
"conn",
":",
"# Check to see if we can login, disabling password prompts",
"command",
"=",
"[",
"'ssh'",
",",
"'-CT'",
",",
"'-o'",
",",
"'BatchMode=yes'",
",",
"hostname",
",",
"'true'",
"]",
"out",
",",
"err",
",",
"retval",
"=",
"remoto",
".",
"process",
".",
"check",
"(",
"conn",
",",
"command",
",",
"stop_on_error",
"=",
"False",
")",
"permission_denied_error",
"=",
"'Permission denied '",
"host_key_verify_error",
"=",
"'Host key verification failed.'",
"has_key_error",
"=",
"False",
"for",
"line",
"in",
"err",
":",
"if",
"permission_denied_error",
"in",
"line",
"or",
"host_key_verify_error",
"in",
"line",
":",
"has_key_error",
"=",
"True",
"if",
"retval",
"==",
"255",
"and",
"has_key_error",
":",
"return",
"False",
"return",
"True"
] | Ensure that current host can SSH remotely to the remote
host using the ``BatchMode`` option to prevent a password prompt.
That attempt will error with an exit status of 255 and a ``Permission
denied`` message or a``Host key verification failed`` message. | [
"Ensure",
"that",
"current",
"host",
"can",
"SSH",
"remotely",
"to",
"the",
"remote",
"host",
"using",
"the",
"BatchMode",
"option",
"to",
"prevent",
"a",
"password",
"prompt",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/ssh.py#L6-L32 |
247,265 | ceph/ceph-deploy | ceph_deploy/util/net.py | ip_in_subnet | def ip_in_subnet(ip, subnet):
"""Does IP exists in a given subnet utility. Returns a boolean"""
ipaddr = int(''.join(['%02x' % int(x) for x in ip.split('.')]), 16)
netstr, bits = subnet.split('/')
netaddr = int(''.join(['%02x' % int(x) for x in netstr.split('.')]), 16)
mask = (0xffffffff << (32 - int(bits))) & 0xffffffff
return (ipaddr & mask) == (netaddr & mask) | python | def ip_in_subnet(ip, subnet):
ipaddr = int(''.join(['%02x' % int(x) for x in ip.split('.')]), 16)
netstr, bits = subnet.split('/')
netaddr = int(''.join(['%02x' % int(x) for x in netstr.split('.')]), 16)
mask = (0xffffffff << (32 - int(bits))) & 0xffffffff
return (ipaddr & mask) == (netaddr & mask) | [
"def",
"ip_in_subnet",
"(",
"ip",
",",
"subnet",
")",
":",
"ipaddr",
"=",
"int",
"(",
"''",
".",
"join",
"(",
"[",
"'%02x'",
"%",
"int",
"(",
"x",
")",
"for",
"x",
"in",
"ip",
".",
"split",
"(",
"'.'",
")",
"]",
")",
",",
"16",
")",
"netstr",
",",
"bits",
"=",
"subnet",
".",
"split",
"(",
"'/'",
")",
"netaddr",
"=",
"int",
"(",
"''",
".",
"join",
"(",
"[",
"'%02x'",
"%",
"int",
"(",
"x",
")",
"for",
"x",
"in",
"netstr",
".",
"split",
"(",
"'.'",
")",
"]",
")",
",",
"16",
")",
"mask",
"=",
"(",
"0xffffffff",
"<<",
"(",
"32",
"-",
"int",
"(",
"bits",
")",
")",
")",
"&",
"0xffffffff",
"return",
"(",
"ipaddr",
"&",
"mask",
")",
"==",
"(",
"netaddr",
"&",
"mask",
")"
] | Does IP exists in a given subnet utility. Returns a boolean | [
"Does",
"IP",
"exists",
"in",
"a",
"given",
"subnet",
"utility",
".",
"Returns",
"a",
"boolean"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/net.py#L52-L58 |
247,266 | ceph/ceph-deploy | ceph_deploy/util/net.py | in_subnet | def in_subnet(cidr, addrs=None):
"""
Returns True if host is within specified subnet, otherwise False
"""
for address in addrs:
if ip_in_subnet(address, cidr):
return True
return False | python | def in_subnet(cidr, addrs=None):
for address in addrs:
if ip_in_subnet(address, cidr):
return True
return False | [
"def",
"in_subnet",
"(",
"cidr",
",",
"addrs",
"=",
"None",
")",
":",
"for",
"address",
"in",
"addrs",
":",
"if",
"ip_in_subnet",
"(",
"address",
",",
"cidr",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True if host is within specified subnet, otherwise False | [
"Returns",
"True",
"if",
"host",
"is",
"within",
"specified",
"subnet",
"otherwise",
"False"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/net.py#L61-L68 |
247,267 | ceph/ceph-deploy | ceph_deploy/util/net.py | get_chacra_repo | def get_chacra_repo(shaman_url):
"""
From a Shaman URL, get the chacra url for a repository, read the
contents that point to the repo and return it as a string.
"""
shaman_response = get_request(shaman_url)
chacra_url = shaman_response.geturl()
chacra_response = get_request(chacra_url)
return chacra_response.read() | python | def get_chacra_repo(shaman_url):
shaman_response = get_request(shaman_url)
chacra_url = shaman_response.geturl()
chacra_response = get_request(chacra_url)
return chacra_response.read() | [
"def",
"get_chacra_repo",
"(",
"shaman_url",
")",
":",
"shaman_response",
"=",
"get_request",
"(",
"shaman_url",
")",
"chacra_url",
"=",
"shaman_response",
".",
"geturl",
"(",
")",
"chacra_response",
"=",
"get_request",
"(",
"chacra_url",
")",
"return",
"chacra_response",
".",
"read",
"(",
")"
] | From a Shaman URL, get the chacra url for a repository, read the
contents that point to the repo and return it as a string. | [
"From",
"a",
"Shaman",
"URL",
"get",
"the",
"chacra",
"url",
"for",
"a",
"repository",
"read",
"the",
"contents",
"that",
"point",
"to",
"the",
"repo",
"and",
"return",
"it",
"as",
"a",
"string",
"."
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/util/net.py#L390-L399 |
247,268 | ceph/ceph-deploy | ceph_deploy/hosts/common.py | map_components | def map_components(notsplit_packages, components):
"""
Returns a list of packages to install based on component names
This is done by checking if a component is in notsplit_packages,
if it is, we know we need to install 'ceph' instead of the
raw component name. Essentially, this component hasn't been
'split' from the master 'ceph' package yet.
"""
packages = set()
for c in components:
if c in notsplit_packages:
packages.add('ceph')
else:
packages.add(c)
return list(packages) | python | def map_components(notsplit_packages, components):
packages = set()
for c in components:
if c in notsplit_packages:
packages.add('ceph')
else:
packages.add(c)
return list(packages) | [
"def",
"map_components",
"(",
"notsplit_packages",
",",
"components",
")",
":",
"packages",
"=",
"set",
"(",
")",
"for",
"c",
"in",
"components",
":",
"if",
"c",
"in",
"notsplit_packages",
":",
"packages",
".",
"add",
"(",
"'ceph'",
")",
"else",
":",
"packages",
".",
"add",
"(",
"c",
")",
"return",
"list",
"(",
"packages",
")"
] | Returns a list of packages to install based on component names
This is done by checking if a component is in notsplit_packages,
if it is, we know we need to install 'ceph' instead of the
raw component name. Essentially, this component hasn't been
'split' from the master 'ceph' package yet. | [
"Returns",
"a",
"list",
"of",
"packages",
"to",
"install",
"based",
"on",
"component",
"names"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/common.py#L165-L182 |
247,269 | ceph/ceph-deploy | ceph_deploy/hosts/common.py | start_mon_service | def start_mon_service(distro, cluster, hostname):
"""
start mon service depending on distro init
"""
if distro.init == 'sysvinit':
service = distro.conn.remote_module.which_service()
remoto.process.run(
distro.conn,
[
service,
'ceph',
'-c',
'/etc/ceph/{cluster}.conf'.format(cluster=cluster),
'start',
'mon.{hostname}'.format(hostname=hostname)
],
timeout=7,
)
system.enable_service(distro.conn)
elif distro.init == 'upstart':
remoto.process.run(
distro.conn,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=cluster),
'id={hostname}'.format(hostname=hostname),
],
timeout=7,
)
elif distro.init == 'systemd':
# enable ceph target for this host (in case it isn't already enabled)
remoto.process.run(
distro.conn,
[
'systemctl',
'enable',
'ceph.target'
],
timeout=7,
)
# enable and start this mon instance
remoto.process.run(
distro.conn,
[
'systemctl',
'enable',
'ceph-mon@{hostname}'.format(hostname=hostname),
],
timeout=7,
)
remoto.process.run(
distro.conn,
[
'systemctl',
'start',
'ceph-mon@{hostname}'.format(hostname=hostname),
],
timeout=7,
) | python | def start_mon_service(distro, cluster, hostname):
if distro.init == 'sysvinit':
service = distro.conn.remote_module.which_service()
remoto.process.run(
distro.conn,
[
service,
'ceph',
'-c',
'/etc/ceph/{cluster}.conf'.format(cluster=cluster),
'start',
'mon.{hostname}'.format(hostname=hostname)
],
timeout=7,
)
system.enable_service(distro.conn)
elif distro.init == 'upstart':
remoto.process.run(
distro.conn,
[
'initctl',
'emit',
'ceph-mon',
'cluster={cluster}'.format(cluster=cluster),
'id={hostname}'.format(hostname=hostname),
],
timeout=7,
)
elif distro.init == 'systemd':
# enable ceph target for this host (in case it isn't already enabled)
remoto.process.run(
distro.conn,
[
'systemctl',
'enable',
'ceph.target'
],
timeout=7,
)
# enable and start this mon instance
remoto.process.run(
distro.conn,
[
'systemctl',
'enable',
'ceph-mon@{hostname}'.format(hostname=hostname),
],
timeout=7,
)
remoto.process.run(
distro.conn,
[
'systemctl',
'start',
'ceph-mon@{hostname}'.format(hostname=hostname),
],
timeout=7,
) | [
"def",
"start_mon_service",
"(",
"distro",
",",
"cluster",
",",
"hostname",
")",
":",
"if",
"distro",
".",
"init",
"==",
"'sysvinit'",
":",
"service",
"=",
"distro",
".",
"conn",
".",
"remote_module",
".",
"which_service",
"(",
")",
"remoto",
".",
"process",
".",
"run",
"(",
"distro",
".",
"conn",
",",
"[",
"service",
",",
"'ceph'",
",",
"'-c'",
",",
"'/etc/ceph/{cluster}.conf'",
".",
"format",
"(",
"cluster",
"=",
"cluster",
")",
",",
"'start'",
",",
"'mon.{hostname}'",
".",
"format",
"(",
"hostname",
"=",
"hostname",
")",
"]",
",",
"timeout",
"=",
"7",
",",
")",
"system",
".",
"enable_service",
"(",
"distro",
".",
"conn",
")",
"elif",
"distro",
".",
"init",
"==",
"'upstart'",
":",
"remoto",
".",
"process",
".",
"run",
"(",
"distro",
".",
"conn",
",",
"[",
"'initctl'",
",",
"'emit'",
",",
"'ceph-mon'",
",",
"'cluster={cluster}'",
".",
"format",
"(",
"cluster",
"=",
"cluster",
")",
",",
"'id={hostname}'",
".",
"format",
"(",
"hostname",
"=",
"hostname",
")",
",",
"]",
",",
"timeout",
"=",
"7",
",",
")",
"elif",
"distro",
".",
"init",
"==",
"'systemd'",
":",
"# enable ceph target for this host (in case it isn't already enabled)",
"remoto",
".",
"process",
".",
"run",
"(",
"distro",
".",
"conn",
",",
"[",
"'systemctl'",
",",
"'enable'",
",",
"'ceph.target'",
"]",
",",
"timeout",
"=",
"7",
",",
")",
"# enable and start this mon instance",
"remoto",
".",
"process",
".",
"run",
"(",
"distro",
".",
"conn",
",",
"[",
"'systemctl'",
",",
"'enable'",
",",
"'ceph-mon@{hostname}'",
".",
"format",
"(",
"hostname",
"=",
"hostname",
")",
",",
"]",
",",
"timeout",
"=",
"7",
",",
")",
"remoto",
".",
"process",
".",
"run",
"(",
"distro",
".",
"conn",
",",
"[",
"'systemctl'",
",",
"'start'",
",",
"'ceph-mon@{hostname}'",
".",
"format",
"(",
"hostname",
"=",
"hostname",
")",
",",
"]",
",",
"timeout",
"=",
"7",
",",
")"
] | start mon service depending on distro init | [
"start",
"mon",
"service",
"depending",
"on",
"distro",
"init"
] | 86943fcc454cd4c99a86e3493e9e93a59c661fef | https://github.com/ceph/ceph-deploy/blob/86943fcc454cd4c99a86e3493e9e93a59c661fef/ceph_deploy/hosts/common.py#L185-L248 |
247,270 | andrea-cuttone/geoplotlib | geoplotlib/layers.py | VoronoiLayer.__voronoi_finite_polygons_2d | def __voronoi_finite_polygons_2d(vor, radius=None):
"""
Reconstruct infinite voronoi regions in a 2D diagram to finite
regions.
Parameters
----------
vor : Voronoi
Input diagram
radius : float, optional
Distance to 'points at infinity'.
Returns
-------
regions : list of tuples
Indices of vertices in each revised Voronoi regions.
vertices : list of tuples
Coordinates for revised Voronoi vertices. Same as coordinates
of input vertices, with 'points at infinity' appended to the
end.
"""
if vor.points.shape[1] != 2:
raise ValueError("Requires 2D input")
new_regions = []
new_vertices = vor.vertices.tolist()
center = vor.points.mean(axis=0)
if radius is None:
radius = vor.points.ptp().max()
# Construct a map containing all ridges for a given point
all_ridges = {}
for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):
all_ridges.setdefault(p1, []).append((p2, v1, v2))
all_ridges.setdefault(p2, []).append((p1, v1, v2))
# Reconstruct infinite regions
for p1, region in enumerate(vor.point_region):
vertices = vor.regions[region]
if all(v >= 0 for v in vertices):
# finite region
new_regions.append(vertices)
continue
# reconstruct a non-finite region
if p1 not in all_ridges:
continue
ridges = all_ridges[p1]
new_region = [v for v in vertices if v >= 0]
for p2, v1, v2 in ridges:
if v2 < 0:
v1, v2 = v2, v1
if v1 >= 0:
# finite ridge: already in the region
continue
# Compute the missing endpoint of an infinite ridge
t = vor.points[p2] - vor.points[p1] # tangent
t /= np.linalg.norm(t)
n = np.array([-t[1], t[0]]) # normal
midpoint = vor.points[[p1, p2]].mean(axis=0)
direction = np.sign(np.dot(midpoint - center, n)) * n
far_point = vor.vertices[v2] + direction * radius
new_region.append(len(new_vertices))
new_vertices.append(far_point.tolist())
# sort region counterclockwise
vs = np.asarray([new_vertices[v] for v in new_region])
c = vs.mean(axis=0)
angles = np.arctan2(vs[:,1] - c[1], vs[:,0] - c[0])
new_region = np.array(new_region)[np.argsort(angles)]
# finish
new_regions.append(new_region.tolist())
return new_regions, np.asarray(new_vertices) | python | def __voronoi_finite_polygons_2d(vor, radius=None):
if vor.points.shape[1] != 2:
raise ValueError("Requires 2D input")
new_regions = []
new_vertices = vor.vertices.tolist()
center = vor.points.mean(axis=0)
if radius is None:
radius = vor.points.ptp().max()
# Construct a map containing all ridges for a given point
all_ridges = {}
for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):
all_ridges.setdefault(p1, []).append((p2, v1, v2))
all_ridges.setdefault(p2, []).append((p1, v1, v2))
# Reconstruct infinite regions
for p1, region in enumerate(vor.point_region):
vertices = vor.regions[region]
if all(v >= 0 for v in vertices):
# finite region
new_regions.append(vertices)
continue
# reconstruct a non-finite region
if p1 not in all_ridges:
continue
ridges = all_ridges[p1]
new_region = [v for v in vertices if v >= 0]
for p2, v1, v2 in ridges:
if v2 < 0:
v1, v2 = v2, v1
if v1 >= 0:
# finite ridge: already in the region
continue
# Compute the missing endpoint of an infinite ridge
t = vor.points[p2] - vor.points[p1] # tangent
t /= np.linalg.norm(t)
n = np.array([-t[1], t[0]]) # normal
midpoint = vor.points[[p1, p2]].mean(axis=0)
direction = np.sign(np.dot(midpoint - center, n)) * n
far_point = vor.vertices[v2] + direction * radius
new_region.append(len(new_vertices))
new_vertices.append(far_point.tolist())
# sort region counterclockwise
vs = np.asarray([new_vertices[v] for v in new_region])
c = vs.mean(axis=0)
angles = np.arctan2(vs[:,1] - c[1], vs[:,0] - c[0])
new_region = np.array(new_region)[np.argsort(angles)]
# finish
new_regions.append(new_region.tolist())
return new_regions, np.asarray(new_vertices) | [
"def",
"__voronoi_finite_polygons_2d",
"(",
"vor",
",",
"radius",
"=",
"None",
")",
":",
"if",
"vor",
".",
"points",
".",
"shape",
"[",
"1",
"]",
"!=",
"2",
":",
"raise",
"ValueError",
"(",
"\"Requires 2D input\"",
")",
"new_regions",
"=",
"[",
"]",
"new_vertices",
"=",
"vor",
".",
"vertices",
".",
"tolist",
"(",
")",
"center",
"=",
"vor",
".",
"points",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
"if",
"radius",
"is",
"None",
":",
"radius",
"=",
"vor",
".",
"points",
".",
"ptp",
"(",
")",
".",
"max",
"(",
")",
"# Construct a map containing all ridges for a given point",
"all_ridges",
"=",
"{",
"}",
"for",
"(",
"p1",
",",
"p2",
")",
",",
"(",
"v1",
",",
"v2",
")",
"in",
"zip",
"(",
"vor",
".",
"ridge_points",
",",
"vor",
".",
"ridge_vertices",
")",
":",
"all_ridges",
".",
"setdefault",
"(",
"p1",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"p2",
",",
"v1",
",",
"v2",
")",
")",
"all_ridges",
".",
"setdefault",
"(",
"p2",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"p1",
",",
"v1",
",",
"v2",
")",
")",
"# Reconstruct infinite regions",
"for",
"p1",
",",
"region",
"in",
"enumerate",
"(",
"vor",
".",
"point_region",
")",
":",
"vertices",
"=",
"vor",
".",
"regions",
"[",
"region",
"]",
"if",
"all",
"(",
"v",
">=",
"0",
"for",
"v",
"in",
"vertices",
")",
":",
"# finite region",
"new_regions",
".",
"append",
"(",
"vertices",
")",
"continue",
"# reconstruct a non-finite region",
"if",
"p1",
"not",
"in",
"all_ridges",
":",
"continue",
"ridges",
"=",
"all_ridges",
"[",
"p1",
"]",
"new_region",
"=",
"[",
"v",
"for",
"v",
"in",
"vertices",
"if",
"v",
">=",
"0",
"]",
"for",
"p2",
",",
"v1",
",",
"v2",
"in",
"ridges",
":",
"if",
"v2",
"<",
"0",
":",
"v1",
",",
"v2",
"=",
"v2",
",",
"v1",
"if",
"v1",
">=",
"0",
":",
"# finite ridge: already in the region",
"continue",
"# Compute the missing endpoint of an infinite ridge",
"t",
"=",
"vor",
".",
"points",
"[",
"p2",
"]",
"-",
"vor",
".",
"points",
"[",
"p1",
"]",
"# tangent",
"t",
"/=",
"np",
".",
"linalg",
".",
"norm",
"(",
"t",
")",
"n",
"=",
"np",
".",
"array",
"(",
"[",
"-",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"0",
"]",
"]",
")",
"# normal",
"midpoint",
"=",
"vor",
".",
"points",
"[",
"[",
"p1",
",",
"p2",
"]",
"]",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
"direction",
"=",
"np",
".",
"sign",
"(",
"np",
".",
"dot",
"(",
"midpoint",
"-",
"center",
",",
"n",
")",
")",
"*",
"n",
"far_point",
"=",
"vor",
".",
"vertices",
"[",
"v2",
"]",
"+",
"direction",
"*",
"radius",
"new_region",
".",
"append",
"(",
"len",
"(",
"new_vertices",
")",
")",
"new_vertices",
".",
"append",
"(",
"far_point",
".",
"tolist",
"(",
")",
")",
"# sort region counterclockwise",
"vs",
"=",
"np",
".",
"asarray",
"(",
"[",
"new_vertices",
"[",
"v",
"]",
"for",
"v",
"in",
"new_region",
"]",
")",
"c",
"=",
"vs",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
"angles",
"=",
"np",
".",
"arctan2",
"(",
"vs",
"[",
":",
",",
"1",
"]",
"-",
"c",
"[",
"1",
"]",
",",
"vs",
"[",
":",
",",
"0",
"]",
"-",
"c",
"[",
"0",
"]",
")",
"new_region",
"=",
"np",
".",
"array",
"(",
"new_region",
")",
"[",
"np",
".",
"argsort",
"(",
"angles",
")",
"]",
"# finish",
"new_regions",
".",
"append",
"(",
"new_region",
".",
"tolist",
"(",
")",
")",
"return",
"new_regions",
",",
"np",
".",
"asarray",
"(",
"new_vertices",
")"
] | Reconstruct infinite voronoi regions in a 2D diagram to finite
regions.
Parameters
----------
vor : Voronoi
Input diagram
radius : float, optional
Distance to 'points at infinity'.
Returns
-------
regions : list of tuples
Indices of vertices in each revised Voronoi regions.
vertices : list of tuples
Coordinates for revised Voronoi vertices. Same as coordinates
of input vertices, with 'points at infinity' appended to the
end. | [
"Reconstruct",
"infinite",
"voronoi",
"regions",
"in",
"a",
"2D",
"diagram",
"to",
"finite",
"regions",
"."
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/layers.py#L505-L589 |
247,271 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | inline | def inline(width=900):
"""display the map inline in ipython
:param width: image width for the browser
"""
from IPython.display import Image, HTML, display, clear_output
import random
import string
import urllib
import os
while True:
fname = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(32))
if not os.path.isfile(fname + '.png'):
break
savefig(fname)
if os.path.isfile(fname + '.png'):
with open(fname + '.png', 'rb') as fin:
encoded = base64.b64encode(fin.read())
b64 = urllib.parse.quote(encoded)
image_html = "<img style='width: %dpx; margin: 0px; float: left; border: 1px solid black;' src='data:image/png;base64,%s' />" % (width, b64)
display(HTML(image_html))
os.remove(fname + '.png') | python | def inline(width=900):
from IPython.display import Image, HTML, display, clear_output
import random
import string
import urllib
import os
while True:
fname = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(32))
if not os.path.isfile(fname + '.png'):
break
savefig(fname)
if os.path.isfile(fname + '.png'):
with open(fname + '.png', 'rb') as fin:
encoded = base64.b64encode(fin.read())
b64 = urllib.parse.quote(encoded)
image_html = "<img style='width: %dpx; margin: 0px; float: left; border: 1px solid black;' src='data:image/png;base64,%s' />" % (width, b64)
display(HTML(image_html))
os.remove(fname + '.png') | [
"def",
"inline",
"(",
"width",
"=",
"900",
")",
":",
"from",
"IPython",
".",
"display",
"import",
"Image",
",",
"HTML",
",",
"display",
",",
"clear_output",
"import",
"random",
"import",
"string",
"import",
"urllib",
"import",
"os",
"while",
"True",
":",
"fname",
"=",
"''",
".",
"join",
"(",
"random",
".",
"choice",
"(",
"string",
".",
"ascii_uppercase",
"+",
"string",
".",
"digits",
")",
"for",
"_",
"in",
"range",
"(",
"32",
")",
")",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"fname",
"+",
"'.png'",
")",
":",
"break",
"savefig",
"(",
"fname",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"fname",
"+",
"'.png'",
")",
":",
"with",
"open",
"(",
"fname",
"+",
"'.png'",
",",
"'rb'",
")",
"as",
"fin",
":",
"encoded",
"=",
"base64",
".",
"b64encode",
"(",
"fin",
".",
"read",
"(",
")",
")",
"b64",
"=",
"urllib",
".",
"parse",
".",
"quote",
"(",
"encoded",
")",
"image_html",
"=",
"\"<img style='width: %dpx; margin: 0px; float: left; border: 1px solid black;' src='data:image/png;base64,%s' />\"",
"%",
"(",
"width",
",",
"b64",
")",
"display",
"(",
"HTML",
"(",
"image_html",
")",
")",
"os",
".",
"remove",
"(",
"fname",
"+",
"'.png'",
")"
] | display the map inline in ipython
:param width: image width for the browser | [
"display",
"the",
"map",
"inline",
"in",
"ipython"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L52-L78 |
247,272 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | dot | def dot(data, color=None, point_size=2, f_tooltip=None):
"""Create a dot density map
:param data: data access object
:param color: color
:param point_size: point size
:param f_tooltip: function to return a tooltip string for a point
"""
from geoplotlib.layers import DotDensityLayer
_global_config.layers.append(DotDensityLayer(data, color=color, point_size=point_size, f_tooltip=f_tooltip)) | python | def dot(data, color=None, point_size=2, f_tooltip=None):
from geoplotlib.layers import DotDensityLayer
_global_config.layers.append(DotDensityLayer(data, color=color, point_size=point_size, f_tooltip=f_tooltip)) | [
"def",
"dot",
"(",
"data",
",",
"color",
"=",
"None",
",",
"point_size",
"=",
"2",
",",
"f_tooltip",
"=",
"None",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"DotDensityLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"DotDensityLayer",
"(",
"data",
",",
"color",
"=",
"color",
",",
"point_size",
"=",
"point_size",
",",
"f_tooltip",
"=",
"f_tooltip",
")",
")"
] | Create a dot density map
:param data: data access object
:param color: color
:param point_size: point size
:param f_tooltip: function to return a tooltip string for a point | [
"Create",
"a",
"dot",
"density",
"map"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L81-L90 |
247,273 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | hist | def hist(data, cmap='hot', alpha=220, colorscale='sqrt', binsize=16, show_tooltip=False,
scalemin=0, scalemax=None, f_group=None, show_colorbar=True):
"""Create a 2D histogram
:param data: data access object
:param cmap: colormap name
:param alpha: color alpha
:param colorscale: scaling [lin, log, sqrt]
:param binsize: size of the hist bins
:param show_tooltip: if True, will show the value of bins on mouseover
:param scalemin: min value for displaying a bin
:param scalemax: max value for a bin
:param f_group: function to apply to samples in the same bin. Default is to count
:param show_colorbar: show colorbar
"""
from geoplotlib.layers import HistogramLayer
_global_config.layers.append(HistogramLayer(data, cmap=cmap, alpha=alpha, colorscale=colorscale,
binsize=binsize, show_tooltip=show_tooltip, scalemin=scalemin,
scalemax=scalemax, f_group=f_group, show_colorbar=show_colorbar)) | python | def hist(data, cmap='hot', alpha=220, colorscale='sqrt', binsize=16, show_tooltip=False,
scalemin=0, scalemax=None, f_group=None, show_colorbar=True):
from geoplotlib.layers import HistogramLayer
_global_config.layers.append(HistogramLayer(data, cmap=cmap, alpha=alpha, colorscale=colorscale,
binsize=binsize, show_tooltip=show_tooltip, scalemin=scalemin,
scalemax=scalemax, f_group=f_group, show_colorbar=show_colorbar)) | [
"def",
"hist",
"(",
"data",
",",
"cmap",
"=",
"'hot'",
",",
"alpha",
"=",
"220",
",",
"colorscale",
"=",
"'sqrt'",
",",
"binsize",
"=",
"16",
",",
"show_tooltip",
"=",
"False",
",",
"scalemin",
"=",
"0",
",",
"scalemax",
"=",
"None",
",",
"f_group",
"=",
"None",
",",
"show_colorbar",
"=",
"True",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"HistogramLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"HistogramLayer",
"(",
"data",
",",
"cmap",
"=",
"cmap",
",",
"alpha",
"=",
"alpha",
",",
"colorscale",
"=",
"colorscale",
",",
"binsize",
"=",
"binsize",
",",
"show_tooltip",
"=",
"show_tooltip",
",",
"scalemin",
"=",
"scalemin",
",",
"scalemax",
"=",
"scalemax",
",",
"f_group",
"=",
"f_group",
",",
"show_colorbar",
"=",
"show_colorbar",
")",
")"
] | Create a 2D histogram
:param data: data access object
:param cmap: colormap name
:param alpha: color alpha
:param colorscale: scaling [lin, log, sqrt]
:param binsize: size of the hist bins
:param show_tooltip: if True, will show the value of bins on mouseover
:param scalemin: min value for displaying a bin
:param scalemax: max value for a bin
:param f_group: function to apply to samples in the same bin. Default is to count
:param show_colorbar: show colorbar | [
"Create",
"a",
"2D",
"histogram"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L101-L119 |
247,274 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | shapefiles | def shapefiles(fname, f_tooltip=None, color=None, linewidth=3, shape_type='full'):
"""
Load and draws shapefiles
:param fname: full path to the shapefile
:param f_tooltip: function to generate a tooltip on mouseover
:param color: color
:param linewidth: line width
:param shape_type: either full or bbox
"""
from geoplotlib.layers import ShapefileLayer
_global_config.layers.append(ShapefileLayer(fname, f_tooltip, color, linewidth, shape_type)) | python | def shapefiles(fname, f_tooltip=None, color=None, linewidth=3, shape_type='full'):
from geoplotlib.layers import ShapefileLayer
_global_config.layers.append(ShapefileLayer(fname, f_tooltip, color, linewidth, shape_type)) | [
"def",
"shapefiles",
"(",
"fname",
",",
"f_tooltip",
"=",
"None",
",",
"color",
"=",
"None",
",",
"linewidth",
"=",
"3",
",",
"shape_type",
"=",
"'full'",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"ShapefileLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"ShapefileLayer",
"(",
"fname",
",",
"f_tooltip",
",",
"color",
",",
"linewidth",
",",
"shape_type",
")",
")"
] | Load and draws shapefiles
:param fname: full path to the shapefile
:param f_tooltip: function to generate a tooltip on mouseover
:param color: color
:param linewidth: line width
:param shape_type: either full or bbox | [
"Load",
"and",
"draws",
"shapefiles"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L138-L149 |
247,275 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | voronoi | def voronoi(data, line_color=None, line_width=2, f_tooltip=None, cmap=None, max_area=1e4, alpha=220):
"""
Draw the voronoi tesselation of the points
:param data: data access object
:param line_color: line color
:param line_width: line width
:param f_tooltip: function to generate a tooltip on mouseover
:param cmap: color map
:param max_area: scaling constant to determine the color of the voronoi areas
:param alpha: color alpha
"""
from geoplotlib.layers import VoronoiLayer
_global_config.layers.append(VoronoiLayer(data, line_color, line_width, f_tooltip, cmap, max_area, alpha)) | python | def voronoi(data, line_color=None, line_width=2, f_tooltip=None, cmap=None, max_area=1e4, alpha=220):
from geoplotlib.layers import VoronoiLayer
_global_config.layers.append(VoronoiLayer(data, line_color, line_width, f_tooltip, cmap, max_area, alpha)) | [
"def",
"voronoi",
"(",
"data",
",",
"line_color",
"=",
"None",
",",
"line_width",
"=",
"2",
",",
"f_tooltip",
"=",
"None",
",",
"cmap",
"=",
"None",
",",
"max_area",
"=",
"1e4",
",",
"alpha",
"=",
"220",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"VoronoiLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"VoronoiLayer",
"(",
"data",
",",
"line_color",
",",
"line_width",
",",
"f_tooltip",
",",
"cmap",
",",
"max_area",
",",
"alpha",
")",
")"
] | Draw the voronoi tesselation of the points
:param data: data access object
:param line_color: line color
:param line_width: line width
:param f_tooltip: function to generate a tooltip on mouseover
:param cmap: color map
:param max_area: scaling constant to determine the color of the voronoi areas
:param alpha: color alpha | [
"Draw",
"the",
"voronoi",
"tesselation",
"of",
"the",
"points"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L152-L165 |
247,276 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | delaunay | def delaunay(data, line_color=None, line_width=2, cmap=None, max_lenght=100):
"""
Draw a delaunay triangulation of the points
:param data: data access object
:param line_color: line color
:param line_width: line width
:param cmap: color map
:param max_lenght: scaling constant for coloring the edges
"""
from geoplotlib.layers import DelaunayLayer
_global_config.layers.append(DelaunayLayer(data, line_color, line_width, cmap, max_lenght)) | python | def delaunay(data, line_color=None, line_width=2, cmap=None, max_lenght=100):
from geoplotlib.layers import DelaunayLayer
_global_config.layers.append(DelaunayLayer(data, line_color, line_width, cmap, max_lenght)) | [
"def",
"delaunay",
"(",
"data",
",",
"line_color",
"=",
"None",
",",
"line_width",
"=",
"2",
",",
"cmap",
"=",
"None",
",",
"max_lenght",
"=",
"100",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"DelaunayLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"DelaunayLayer",
"(",
"data",
",",
"line_color",
",",
"line_width",
",",
"cmap",
",",
"max_lenght",
")",
")"
] | Draw a delaunay triangulation of the points
:param data: data access object
:param line_color: line color
:param line_width: line width
:param cmap: color map
:param max_lenght: scaling constant for coloring the edges | [
"Draw",
"a",
"delaunay",
"triangulation",
"of",
"the",
"points"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L168-L179 |
247,277 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | convexhull | def convexhull(data, col, fill=True, point_size=4):
"""
Convex hull for a set of points
:param data: points
:param col: color
:param fill: whether to fill the convexhull polygon or not
:param point_size: size of the points on the convexhull. Points are not rendered if None
"""
from geoplotlib.layers import ConvexHullLayer
_global_config.layers.append(ConvexHullLayer(data, col, fill, point_size)) | python | def convexhull(data, col, fill=True, point_size=4):
from geoplotlib.layers import ConvexHullLayer
_global_config.layers.append(ConvexHullLayer(data, col, fill, point_size)) | [
"def",
"convexhull",
"(",
"data",
",",
"col",
",",
"fill",
"=",
"True",
",",
"point_size",
"=",
"4",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"ConvexHullLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"ConvexHullLayer",
"(",
"data",
",",
"col",
",",
"fill",
",",
"point_size",
")",
")"
] | Convex hull for a set of points
:param data: points
:param col: color
:param fill: whether to fill the convexhull polygon or not
:param point_size: size of the points on the convexhull. Points are not rendered if None | [
"Convex",
"hull",
"for",
"a",
"set",
"of",
"points"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L182-L192 |
247,278 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | kde | def kde(data, bw, cmap='hot', method='hist', scaling='sqrt', alpha=220,
cut_below=None, clip_above=None, binsize=1, cmap_levels=10, show_colorbar=False):
"""
Kernel density estimation visualization
:param data: data access object
:param bw: kernel bandwidth (in screen coordinates)
:param cmap: colormap
:param method: if kde use KDEMultivariate from statsmodel, which provides a more accurate but much slower estimation.
If hist, estimates density applying gaussian smoothing on a 2D histogram, which is much faster but less accurate
:param scaling: colorscale, lin log or sqrt
:param alpha: color alpha
:param cut_below: densities below cut_below are not drawn
:param clip_above: defines the max value for the colorscale
:param binsize: size of the bins for hist estimator
:param cmap_levels: discretize colors into cmap_levels levels
:param show_colorbar: show colorbar
"""
from geoplotlib.layers import KDELayer
_global_config.layers.append(KDELayer(data, bw, cmap, method, scaling, alpha,
cut_below, clip_above, binsize, cmap_levels, show_colorbar)) | python | def kde(data, bw, cmap='hot', method='hist', scaling='sqrt', alpha=220,
cut_below=None, clip_above=None, binsize=1, cmap_levels=10, show_colorbar=False):
from geoplotlib.layers import KDELayer
_global_config.layers.append(KDELayer(data, bw, cmap, method, scaling, alpha,
cut_below, clip_above, binsize, cmap_levels, show_colorbar)) | [
"def",
"kde",
"(",
"data",
",",
"bw",
",",
"cmap",
"=",
"'hot'",
",",
"method",
"=",
"'hist'",
",",
"scaling",
"=",
"'sqrt'",
",",
"alpha",
"=",
"220",
",",
"cut_below",
"=",
"None",
",",
"clip_above",
"=",
"None",
",",
"binsize",
"=",
"1",
",",
"cmap_levels",
"=",
"10",
",",
"show_colorbar",
"=",
"False",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"KDELayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"KDELayer",
"(",
"data",
",",
"bw",
",",
"cmap",
",",
"method",
",",
"scaling",
",",
"alpha",
",",
"cut_below",
",",
"clip_above",
",",
"binsize",
",",
"cmap_levels",
",",
"show_colorbar",
")",
")"
] | Kernel density estimation visualization
:param data: data access object
:param bw: kernel bandwidth (in screen coordinates)
:param cmap: colormap
:param method: if kde use KDEMultivariate from statsmodel, which provides a more accurate but much slower estimation.
If hist, estimates density applying gaussian smoothing on a 2D histogram, which is much faster but less accurate
:param scaling: colorscale, lin log or sqrt
:param alpha: color alpha
:param cut_below: densities below cut_below are not drawn
:param clip_above: defines the max value for the colorscale
:param binsize: size of the bins for hist estimator
:param cmap_levels: discretize colors into cmap_levels levels
:param show_colorbar: show colorbar | [
"Kernel",
"density",
"estimation",
"visualization"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L195-L215 |
247,279 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | labels | def labels(data, label_column, color=None, font_name=FONT_NAME,
font_size=14, anchor_x='left', anchor_y='top'):
"""
Draw a text label for each sample
:param data: data access object
:param label_column: column in the data access object where the labels text is stored
:param color: color
:param font_name: font name
:param font_size: font size
:param anchor_x: anchor x
:param anchor_y: anchor y
"""
from geoplotlib.layers import LabelsLayer
_global_config.layers.append(LabelsLayer(data, label_column, color, font_name,
font_size, anchor_x, anchor_y)) | python | def labels(data, label_column, color=None, font_name=FONT_NAME,
font_size=14, anchor_x='left', anchor_y='top'):
from geoplotlib.layers import LabelsLayer
_global_config.layers.append(LabelsLayer(data, label_column, color, font_name,
font_size, anchor_x, anchor_y)) | [
"def",
"labels",
"(",
"data",
",",
"label_column",
",",
"color",
"=",
"None",
",",
"font_name",
"=",
"FONT_NAME",
",",
"font_size",
"=",
"14",
",",
"anchor_x",
"=",
"'left'",
",",
"anchor_y",
"=",
"'top'",
")",
":",
"from",
"geoplotlib",
".",
"layers",
"import",
"LabelsLayer",
"_global_config",
".",
"layers",
".",
"append",
"(",
"LabelsLayer",
"(",
"data",
",",
"label_column",
",",
"color",
",",
"font_name",
",",
"font_size",
",",
"anchor_x",
",",
"anchor_y",
")",
")"
] | Draw a text label for each sample
:param data: data access object
:param label_column: column in the data access object where the labels text is stored
:param color: color
:param font_name: font name
:param font_size: font size
:param anchor_x: anchor x
:param anchor_y: anchor y | [
"Draw",
"a",
"text",
"label",
"for",
"each",
"sample"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L245-L260 |
247,280 | andrea-cuttone/geoplotlib | geoplotlib/__init__.py | set_map_alpha | def set_map_alpha(alpha):
"""
Alpha color of the map tiles
:param alpha: int between 0 and 255. 0 is completely dark, 255 is full brightness
"""
if alpha < 0 or alpha > 255:
raise Exception('invalid alpha ' + str(alpha))
_global_config.map_alpha = alpha | python | def set_map_alpha(alpha):
if alpha < 0 or alpha > 255:
raise Exception('invalid alpha ' + str(alpha))
_global_config.map_alpha = alpha | [
"def",
"set_map_alpha",
"(",
"alpha",
")",
":",
"if",
"alpha",
"<",
"0",
"or",
"alpha",
">",
"255",
":",
"raise",
"Exception",
"(",
"'invalid alpha '",
"+",
"str",
"(",
"alpha",
")",
")",
"_global_config",
".",
"map_alpha",
"=",
"alpha"
] | Alpha color of the map tiles
:param alpha: int between 0 and 255. 0 is completely dark, 255 is full brightness | [
"Alpha",
"color",
"of",
"the",
"map",
"tiles"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/__init__.py#L332-L340 |
247,281 | andrea-cuttone/geoplotlib | geoplotlib/utils.py | read_csv | def read_csv(fname):
"""
Read a csv file into a DataAccessObject
:param fname: filename
"""
values = defaultdict(list)
with open(fname) as f:
reader = csv.DictReader(f)
for row in reader:
for (k,v) in row.items():
values[k].append(v)
npvalues = {k: np.array(values[k]) for k in values.keys()}
for k in npvalues.keys():
for datatype in [np.int, np.float]:
try:
npvalues[k][:1].astype(datatype)
npvalues[k] = npvalues[k].astype(datatype)
break
except:
pass
dao = DataAccessObject(npvalues)
return dao | python | def read_csv(fname):
values = defaultdict(list)
with open(fname) as f:
reader = csv.DictReader(f)
for row in reader:
for (k,v) in row.items():
values[k].append(v)
npvalues = {k: np.array(values[k]) for k in values.keys()}
for k in npvalues.keys():
for datatype in [np.int, np.float]:
try:
npvalues[k][:1].astype(datatype)
npvalues[k] = npvalues[k].astype(datatype)
break
except:
pass
dao = DataAccessObject(npvalues)
return dao | [
"def",
"read_csv",
"(",
"fname",
")",
":",
"values",
"=",
"defaultdict",
"(",
"list",
")",
"with",
"open",
"(",
"fname",
")",
"as",
"f",
":",
"reader",
"=",
"csv",
".",
"DictReader",
"(",
"f",
")",
"for",
"row",
"in",
"reader",
":",
"for",
"(",
"k",
",",
"v",
")",
"in",
"row",
".",
"items",
"(",
")",
":",
"values",
"[",
"k",
"]",
".",
"append",
"(",
"v",
")",
"npvalues",
"=",
"{",
"k",
":",
"np",
".",
"array",
"(",
"values",
"[",
"k",
"]",
")",
"for",
"k",
"in",
"values",
".",
"keys",
"(",
")",
"}",
"for",
"k",
"in",
"npvalues",
".",
"keys",
"(",
")",
":",
"for",
"datatype",
"in",
"[",
"np",
".",
"int",
",",
"np",
".",
"float",
"]",
":",
"try",
":",
"npvalues",
"[",
"k",
"]",
"[",
":",
"1",
"]",
".",
"astype",
"(",
"datatype",
")",
"npvalues",
"[",
"k",
"]",
"=",
"npvalues",
"[",
"k",
"]",
".",
"astype",
"(",
"datatype",
")",
"break",
"except",
":",
"pass",
"dao",
"=",
"DataAccessObject",
"(",
"npvalues",
")",
"return",
"dao"
] | Read a csv file into a DataAccessObject
:param fname: filename | [
"Read",
"a",
"csv",
"file",
"into",
"a",
"DataAccessObject"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/utils.py#L141-L163 |
247,282 | andrea-cuttone/geoplotlib | geoplotlib/utils.py | DataAccessObject.head | def head(self, n):
"""
Return a DataAccessObject containing the first n rows
:param n: number of rows
:return: DataAccessObject
"""
return DataAccessObject({k: self.dict[k][:n] for k in self.dict}) | python | def head(self, n):
return DataAccessObject({k: self.dict[k][:n] for k in self.dict}) | [
"def",
"head",
"(",
"self",
",",
"n",
")",
":",
"return",
"DataAccessObject",
"(",
"{",
"k",
":",
"self",
".",
"dict",
"[",
"k",
"]",
"[",
":",
"n",
"]",
"for",
"k",
"in",
"self",
".",
"dict",
"}",
")"
] | Return a DataAccessObject containing the first n rows
:param n: number of rows
:return: DataAccessObject | [
"Return",
"a",
"DataAccessObject",
"containing",
"the",
"first",
"n",
"rows"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/utils.py#L104-L111 |
247,283 | andrea-cuttone/geoplotlib | geoplotlib/utils.py | BoundingBox.from_points | def from_points(lons, lats):
"""
Compute the BoundingBox from a set of latitudes and longitudes
:param lons: longitudes
:param lats: latitudes
:return: BoundingBox
"""
north, west = max(lats), min(lons)
south, east = min(lats), max(lons)
return BoundingBox(north=north, west=west, south=south, east=east) | python | def from_points(lons, lats):
north, west = max(lats), min(lons)
south, east = min(lats), max(lons)
return BoundingBox(north=north, west=west, south=south, east=east) | [
"def",
"from_points",
"(",
"lons",
",",
"lats",
")",
":",
"north",
",",
"west",
"=",
"max",
"(",
"lats",
")",
",",
"min",
"(",
"lons",
")",
"south",
",",
"east",
"=",
"min",
"(",
"lats",
")",
",",
"max",
"(",
"lons",
")",
"return",
"BoundingBox",
"(",
"north",
"=",
"north",
",",
"west",
"=",
"west",
",",
"south",
"=",
"south",
",",
"east",
"=",
"east",
")"
] | Compute the BoundingBox from a set of latitudes and longitudes
:param lons: longitudes
:param lats: latitudes
:return: BoundingBox | [
"Compute",
"the",
"BoundingBox",
"from",
"a",
"set",
"of",
"latitudes",
"and",
"longitudes"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/utils.py#L207-L217 |
247,284 | andrea-cuttone/geoplotlib | geoplotlib/utils.py | BoundingBox.from_bboxes | def from_bboxes(bboxes):
"""
Compute a BoundingBox enclosing all specified bboxes
:param bboxes: a list of BoundingBoxes
:return: BoundingBox
"""
north = max([b.north for b in bboxes])
south = min([b.south for b in bboxes])
west = min([b.west for b in bboxes])
east = max([b.east for b in bboxes])
return BoundingBox(north=north, west=west, south=south, east=east) | python | def from_bboxes(bboxes):
north = max([b.north for b in bboxes])
south = min([b.south for b in bboxes])
west = min([b.west for b in bboxes])
east = max([b.east for b in bboxes])
return BoundingBox(north=north, west=west, south=south, east=east) | [
"def",
"from_bboxes",
"(",
"bboxes",
")",
":",
"north",
"=",
"max",
"(",
"[",
"b",
".",
"north",
"for",
"b",
"in",
"bboxes",
"]",
")",
"south",
"=",
"min",
"(",
"[",
"b",
".",
"south",
"for",
"b",
"in",
"bboxes",
"]",
")",
"west",
"=",
"min",
"(",
"[",
"b",
".",
"west",
"for",
"b",
"in",
"bboxes",
"]",
")",
"east",
"=",
"max",
"(",
"[",
"b",
".",
"east",
"for",
"b",
"in",
"bboxes",
"]",
")",
"return",
"BoundingBox",
"(",
"north",
"=",
"north",
",",
"west",
"=",
"west",
",",
"south",
"=",
"south",
",",
"east",
"=",
"east",
")"
] | Compute a BoundingBox enclosing all specified bboxes
:param bboxes: a list of BoundingBoxes
:return: BoundingBox | [
"Compute",
"a",
"BoundingBox",
"enclosing",
"all",
"specified",
"bboxes"
] | a1c355bccec91cabd157569fad6daf53cf7687a1 | https://github.com/andrea-cuttone/geoplotlib/blob/a1c355bccec91cabd157569fad6daf53cf7687a1/geoplotlib/utils.py#L221-L232 |
247,285 | jorgenschaefer/elpy | elpy/pydocutils.py | get_pydoc_completions | def get_pydoc_completions(modulename):
"""Get possible completions for modulename for pydoc.
Returns a list of possible values to be passed to pydoc.
"""
modulename = compat.ensure_not_unicode(modulename)
modulename = modulename.rstrip(".")
if modulename == "":
return sorted(get_modules())
candidates = get_completions(modulename)
if candidates:
return sorted(candidates)
needle = modulename
if "." in needle:
modulename, part = needle.rsplit(".", 1)
candidates = get_completions(modulename)
else:
candidates = get_modules()
return sorted(candidate for candidate in candidates
if candidate.startswith(needle)) | python | def get_pydoc_completions(modulename):
modulename = compat.ensure_not_unicode(modulename)
modulename = modulename.rstrip(".")
if modulename == "":
return sorted(get_modules())
candidates = get_completions(modulename)
if candidates:
return sorted(candidates)
needle = modulename
if "." in needle:
modulename, part = needle.rsplit(".", 1)
candidates = get_completions(modulename)
else:
candidates = get_modules()
return sorted(candidate for candidate in candidates
if candidate.startswith(needle)) | [
"def",
"get_pydoc_completions",
"(",
"modulename",
")",
":",
"modulename",
"=",
"compat",
".",
"ensure_not_unicode",
"(",
"modulename",
")",
"modulename",
"=",
"modulename",
".",
"rstrip",
"(",
"\".\"",
")",
"if",
"modulename",
"==",
"\"\"",
":",
"return",
"sorted",
"(",
"get_modules",
"(",
")",
")",
"candidates",
"=",
"get_completions",
"(",
"modulename",
")",
"if",
"candidates",
":",
"return",
"sorted",
"(",
"candidates",
")",
"needle",
"=",
"modulename",
"if",
"\".\"",
"in",
"needle",
":",
"modulename",
",",
"part",
"=",
"needle",
".",
"rsplit",
"(",
"\".\"",
",",
"1",
")",
"candidates",
"=",
"get_completions",
"(",
"modulename",
")",
"else",
":",
"candidates",
"=",
"get_modules",
"(",
")",
"return",
"sorted",
"(",
"candidate",
"for",
"candidate",
"in",
"candidates",
"if",
"candidate",
".",
"startswith",
"(",
"needle",
")",
")"
] | Get possible completions for modulename for pydoc.
Returns a list of possible values to be passed to pydoc. | [
"Get",
"possible",
"completions",
"for",
"modulename",
"for",
"pydoc",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/pydocutils.py#L24-L44 |
247,286 | jorgenschaefer/elpy | elpy/pydocutils.py | get_modules | def get_modules(modulename=None):
"""Return a list of modules and packages under modulename.
If modulename is not given, return a list of all top level modules
and packages.
"""
modulename = compat.ensure_not_unicode(modulename)
if not modulename:
try:
return ([modname for (importer, modname, ispkg)
in iter_modules()
if not modname.startswith("_")] +
list(sys.builtin_module_names))
except OSError:
# Bug in Python 2.6, see #275
return list(sys.builtin_module_names)
try:
module = safeimport(modulename)
except ErrorDuringImport:
return []
if module is None:
return []
if hasattr(module, "__path__"):
return [modname for (importer, modname, ispkg)
in iter_modules(module.__path__)
if not modname.startswith("_")]
return [] | python | def get_modules(modulename=None):
modulename = compat.ensure_not_unicode(modulename)
if not modulename:
try:
return ([modname for (importer, modname, ispkg)
in iter_modules()
if not modname.startswith("_")] +
list(sys.builtin_module_names))
except OSError:
# Bug in Python 2.6, see #275
return list(sys.builtin_module_names)
try:
module = safeimport(modulename)
except ErrorDuringImport:
return []
if module is None:
return []
if hasattr(module, "__path__"):
return [modname for (importer, modname, ispkg)
in iter_modules(module.__path__)
if not modname.startswith("_")]
return [] | [
"def",
"get_modules",
"(",
"modulename",
"=",
"None",
")",
":",
"modulename",
"=",
"compat",
".",
"ensure_not_unicode",
"(",
"modulename",
")",
"if",
"not",
"modulename",
":",
"try",
":",
"return",
"(",
"[",
"modname",
"for",
"(",
"importer",
",",
"modname",
",",
"ispkg",
")",
"in",
"iter_modules",
"(",
")",
"if",
"not",
"modname",
".",
"startswith",
"(",
"\"_\"",
")",
"]",
"+",
"list",
"(",
"sys",
".",
"builtin_module_names",
")",
")",
"except",
"OSError",
":",
"# Bug in Python 2.6, see #275",
"return",
"list",
"(",
"sys",
".",
"builtin_module_names",
")",
"try",
":",
"module",
"=",
"safeimport",
"(",
"modulename",
")",
"except",
"ErrorDuringImport",
":",
"return",
"[",
"]",
"if",
"module",
"is",
"None",
":",
"return",
"[",
"]",
"if",
"hasattr",
"(",
"module",
",",
"\"__path__\"",
")",
":",
"return",
"[",
"modname",
"for",
"(",
"importer",
",",
"modname",
",",
"ispkg",
")",
"in",
"iter_modules",
"(",
"module",
".",
"__path__",
")",
"if",
"not",
"modname",
".",
"startswith",
"(",
"\"_\"",
")",
"]",
"return",
"[",
"]"
] | Return a list of modules and packages under modulename.
If modulename is not given, return a list of all top level modules
and packages. | [
"Return",
"a",
"list",
"of",
"modules",
"and",
"packages",
"under",
"modulename",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/pydocutils.py#L64-L91 |
247,287 | jorgenschaefer/elpy | elpy/rpc.py | JSONRPCServer.read_json | def read_json(self):
"""Read a single line and decode it as JSON.
Can raise an EOFError() when the input source was closed.
"""
line = self.stdin.readline()
if line == '':
raise EOFError()
return json.loads(line) | python | def read_json(self):
line = self.stdin.readline()
if line == '':
raise EOFError()
return json.loads(line) | [
"def",
"read_json",
"(",
"self",
")",
":",
"line",
"=",
"self",
".",
"stdin",
".",
"readline",
"(",
")",
"if",
"line",
"==",
"''",
":",
"raise",
"EOFError",
"(",
")",
"return",
"json",
".",
"loads",
"(",
"line",
")"
] | Read a single line and decode it as JSON.
Can raise an EOFError() when the input source was closed. | [
"Read",
"a",
"single",
"line",
"and",
"decode",
"it",
"as",
"JSON",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/rpc.py#L59-L68 |
247,288 | jorgenschaefer/elpy | elpy/rpc.py | JSONRPCServer.write_json | def write_json(self, **kwargs):
"""Write an JSON object on a single line.
The keyword arguments are interpreted as a single JSON object.
It's not possible with this method to write non-objects.
"""
self.stdout.write(json.dumps(kwargs) + "\n")
self.stdout.flush() | python | def write_json(self, **kwargs):
self.stdout.write(json.dumps(kwargs) + "\n")
self.stdout.flush() | [
"def",
"write_json",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"stdout",
".",
"write",
"(",
"json",
".",
"dumps",
"(",
"kwargs",
")",
"+",
"\"\\n\"",
")",
"self",
".",
"stdout",
".",
"flush",
"(",
")"
] | Write an JSON object on a single line.
The keyword arguments are interpreted as a single JSON object.
It's not possible with this method to write non-objects. | [
"Write",
"an",
"JSON",
"object",
"on",
"a",
"single",
"line",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/rpc.py#L70-L78 |
247,289 | jorgenschaefer/elpy | elpy/rpc.py | JSONRPCServer.handle_request | def handle_request(self):
"""Handle a single JSON-RPC request.
Read a request, call the appropriate handler method, and
return the encoded result. Errors in the handler method are
caught and encoded as error objects. Errors in the decoding
phase are not caught, as we can not respond with an error
response to them.
"""
request = self.read_json()
if 'method' not in request:
raise ValueError("Received a bad request: {0}"
.format(request))
method_name = request['method']
request_id = request.get('id', None)
params = request.get('params') or []
try:
method = getattr(self, "rpc_" + method_name, None)
if method is not None:
result = method(*params)
else:
result = self.handle(method_name, params)
if request_id is not None:
self.write_json(result=result,
id=request_id)
except Fault as fault:
error = {"message": fault.message,
"code": fault.code}
if fault.data is not None:
error["data"] = fault.data
self.write_json(error=error, id=request_id)
except Exception as e:
error = {"message": str(e),
"code": 500,
"data": {"traceback": traceback.format_exc()}}
self.write_json(error=error, id=request_id) | python | def handle_request(self):
request = self.read_json()
if 'method' not in request:
raise ValueError("Received a bad request: {0}"
.format(request))
method_name = request['method']
request_id = request.get('id', None)
params = request.get('params') or []
try:
method = getattr(self, "rpc_" + method_name, None)
if method is not None:
result = method(*params)
else:
result = self.handle(method_name, params)
if request_id is not None:
self.write_json(result=result,
id=request_id)
except Fault as fault:
error = {"message": fault.message,
"code": fault.code}
if fault.data is not None:
error["data"] = fault.data
self.write_json(error=error, id=request_id)
except Exception as e:
error = {"message": str(e),
"code": 500,
"data": {"traceback": traceback.format_exc()}}
self.write_json(error=error, id=request_id) | [
"def",
"handle_request",
"(",
"self",
")",
":",
"request",
"=",
"self",
".",
"read_json",
"(",
")",
"if",
"'method'",
"not",
"in",
"request",
":",
"raise",
"ValueError",
"(",
"\"Received a bad request: {0}\"",
".",
"format",
"(",
"request",
")",
")",
"method_name",
"=",
"request",
"[",
"'method'",
"]",
"request_id",
"=",
"request",
".",
"get",
"(",
"'id'",
",",
"None",
")",
"params",
"=",
"request",
".",
"get",
"(",
"'params'",
")",
"or",
"[",
"]",
"try",
":",
"method",
"=",
"getattr",
"(",
"self",
",",
"\"rpc_\"",
"+",
"method_name",
",",
"None",
")",
"if",
"method",
"is",
"not",
"None",
":",
"result",
"=",
"method",
"(",
"*",
"params",
")",
"else",
":",
"result",
"=",
"self",
".",
"handle",
"(",
"method_name",
",",
"params",
")",
"if",
"request_id",
"is",
"not",
"None",
":",
"self",
".",
"write_json",
"(",
"result",
"=",
"result",
",",
"id",
"=",
"request_id",
")",
"except",
"Fault",
"as",
"fault",
":",
"error",
"=",
"{",
"\"message\"",
":",
"fault",
".",
"message",
",",
"\"code\"",
":",
"fault",
".",
"code",
"}",
"if",
"fault",
".",
"data",
"is",
"not",
"None",
":",
"error",
"[",
"\"data\"",
"]",
"=",
"fault",
".",
"data",
"self",
".",
"write_json",
"(",
"error",
"=",
"error",
",",
"id",
"=",
"request_id",
")",
"except",
"Exception",
"as",
"e",
":",
"error",
"=",
"{",
"\"message\"",
":",
"str",
"(",
"e",
")",
",",
"\"code\"",
":",
"500",
",",
"\"data\"",
":",
"{",
"\"traceback\"",
":",
"traceback",
".",
"format_exc",
"(",
")",
"}",
"}",
"self",
".",
"write_json",
"(",
"error",
"=",
"error",
",",
"id",
"=",
"request_id",
")"
] | Handle a single JSON-RPC request.
Read a request, call the appropriate handler method, and
return the encoded result. Errors in the handler method are
caught and encoded as error objects. Errors in the decoding
phase are not caught, as we can not respond with an error
response to them. | [
"Handle",
"a",
"single",
"JSON",
"-",
"RPC",
"request",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/rpc.py#L80-L116 |
247,290 | jorgenschaefer/elpy | elpy/server.py | get_source | def get_source(fileobj):
"""Translate fileobj into file contents.
fileobj is either a string or a dict. If it's a string, that's the
file contents. If it's a string, then the filename key contains
the name of the file whose contents we are to use.
If the dict contains a true value for the key delete_after_use,
the file should be deleted once read.
"""
if not isinstance(fileobj, dict):
return fileobj
else:
try:
with io.open(fileobj["filename"], encoding="utf-8",
errors="ignore") as f:
return f.read()
finally:
if fileobj.get('delete_after_use'):
try:
os.remove(fileobj["filename"])
except: # pragma: no cover
pass | python | def get_source(fileobj):
if not isinstance(fileobj, dict):
return fileobj
else:
try:
with io.open(fileobj["filename"], encoding="utf-8",
errors="ignore") as f:
return f.read()
finally:
if fileobj.get('delete_after_use'):
try:
os.remove(fileobj["filename"])
except: # pragma: no cover
pass | [
"def",
"get_source",
"(",
"fileobj",
")",
":",
"if",
"not",
"isinstance",
"(",
"fileobj",
",",
"dict",
")",
":",
"return",
"fileobj",
"else",
":",
"try",
":",
"with",
"io",
".",
"open",
"(",
"fileobj",
"[",
"\"filename\"",
"]",
",",
"encoding",
"=",
"\"utf-8\"",
",",
"errors",
"=",
"\"ignore\"",
")",
"as",
"f",
":",
"return",
"f",
".",
"read",
"(",
")",
"finally",
":",
"if",
"fileobj",
".",
"get",
"(",
"'delete_after_use'",
")",
":",
"try",
":",
"os",
".",
"remove",
"(",
"fileobj",
"[",
"\"filename\"",
"]",
")",
"except",
":",
"# pragma: no cover",
"pass"
] | Translate fileobj into file contents.
fileobj is either a string or a dict. If it's a string, that's the
file contents. If it's a string, then the filename key contains
the name of the file whose contents we are to use.
If the dict contains a true value for the key delete_after_use,
the file should be deleted once read. | [
"Translate",
"fileobj",
"into",
"file",
"contents",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L232-L255 |
247,291 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer._call_backend | def _call_backend(self, method, default, *args, **kwargs):
"""Call the backend method with args.
If there is currently no backend, return default."""
meth = getattr(self.backend, method, None)
if meth is None:
return default
else:
return meth(*args, **kwargs) | python | def _call_backend(self, method, default, *args, **kwargs):
meth = getattr(self.backend, method, None)
if meth is None:
return default
else:
return meth(*args, **kwargs) | [
"def",
"_call_backend",
"(",
"self",
",",
"method",
",",
"default",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"meth",
"=",
"getattr",
"(",
"self",
".",
"backend",
",",
"method",
",",
"None",
")",
"if",
"meth",
"is",
"None",
":",
"return",
"default",
"else",
":",
"return",
"meth",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Call the backend method with args.
If there is currently no backend, return default. | [
"Call",
"the",
"backend",
"method",
"with",
"args",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L36-L44 |
247,292 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_calltip | def rpc_get_calltip(self, filename, source, offset):
"""Get the calltip for the function at the offset.
"""
return self._call_backend("rpc_get_calltip", None, filename,
get_source(source), offset) | python | def rpc_get_calltip(self, filename, source, offset):
return self._call_backend("rpc_get_calltip", None, filename,
get_source(source), offset) | [
"def",
"rpc_get_calltip",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"return",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_calltip\"",
",",
"None",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")"
] | Get the calltip for the function at the offset. | [
"Get",
"the",
"calltip",
"for",
"the",
"function",
"at",
"the",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L67-L72 |
247,293 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_oneline_docstring | def rpc_get_oneline_docstring(self, filename, source, offset):
"""Get a oneline docstring for the symbol at the offset.
"""
return self._call_backend("rpc_get_oneline_docstring", None, filename,
get_source(source), offset) | python | def rpc_get_oneline_docstring(self, filename, source, offset):
return self._call_backend("rpc_get_oneline_docstring", None, filename,
get_source(source), offset) | [
"def",
"rpc_get_oneline_docstring",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"return",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_oneline_docstring\"",
",",
"None",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")"
] | Get a oneline docstring for the symbol at the offset. | [
"Get",
"a",
"oneline",
"docstring",
"for",
"the",
"symbol",
"at",
"the",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L74-L79 |
247,294 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_completions | def rpc_get_completions(self, filename, source, offset):
"""Get a list of completion candidates for the symbol at offset.
"""
results = self._call_backend("rpc_get_completions", [], filename,
get_source(source), offset)
# Uniquify by name
results = list(dict((res['name'], res) for res in results)
.values())
results.sort(key=lambda cand: _pysymbol_key(cand["name"]))
return results | python | def rpc_get_completions(self, filename, source, offset):
results = self._call_backend("rpc_get_completions", [], filename,
get_source(source), offset)
# Uniquify by name
results = list(dict((res['name'], res) for res in results)
.values())
results.sort(key=lambda cand: _pysymbol_key(cand["name"]))
return results | [
"def",
"rpc_get_completions",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"results",
"=",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_completions\"",
",",
"[",
"]",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")",
"# Uniquify by name",
"results",
"=",
"list",
"(",
"dict",
"(",
"(",
"res",
"[",
"'name'",
"]",
",",
"res",
")",
"for",
"res",
"in",
"results",
")",
".",
"values",
"(",
")",
")",
"results",
".",
"sort",
"(",
"key",
"=",
"lambda",
"cand",
":",
"_pysymbol_key",
"(",
"cand",
"[",
"\"name\"",
"]",
")",
")",
"return",
"results"
] | Get a list of completion candidates for the symbol at offset. | [
"Get",
"a",
"list",
"of",
"completion",
"candidates",
"for",
"the",
"symbol",
"at",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L81-L91 |
247,295 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_definition | def rpc_get_definition(self, filename, source, offset):
"""Get the location of the definition for the symbol at the offset.
"""
return self._call_backend("rpc_get_definition", None, filename,
get_source(source), offset) | python | def rpc_get_definition(self, filename, source, offset):
return self._call_backend("rpc_get_definition", None, filename,
get_source(source), offset) | [
"def",
"rpc_get_definition",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"return",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_definition\"",
",",
"None",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")"
] | Get the location of the definition for the symbol at the offset. | [
"Get",
"the",
"location",
"of",
"the",
"definition",
"for",
"the",
"symbol",
"at",
"the",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L109-L114 |
247,296 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_assignment | def rpc_get_assignment(self, filename, source, offset):
"""Get the location of the assignment for the symbol at the offset.
"""
return self._call_backend("rpc_get_assignment", None, filename,
get_source(source), offset) | python | def rpc_get_assignment(self, filename, source, offset):
return self._call_backend("rpc_get_assignment", None, filename,
get_source(source), offset) | [
"def",
"rpc_get_assignment",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"return",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_assignment\"",
",",
"None",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")"
] | Get the location of the assignment for the symbol at the offset. | [
"Get",
"the",
"location",
"of",
"the",
"assignment",
"for",
"the",
"symbol",
"at",
"the",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L116-L121 |
247,297 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_docstring | def rpc_get_docstring(self, filename, source, offset):
"""Get the docstring for the symbol at the offset.
"""
return self._call_backend("rpc_get_docstring", None, filename,
get_source(source), offset) | python | def rpc_get_docstring(self, filename, source, offset):
return self._call_backend("rpc_get_docstring", None, filename,
get_source(source), offset) | [
"def",
"rpc_get_docstring",
"(",
"self",
",",
"filename",
",",
"source",
",",
"offset",
")",
":",
"return",
"self",
".",
"_call_backend",
"(",
"\"rpc_get_docstring\"",
",",
"None",
",",
"filename",
",",
"get_source",
"(",
"source",
")",
",",
"offset",
")"
] | Get the docstring for the symbol at the offset. | [
"Get",
"the",
"docstring",
"for",
"the",
"symbol",
"at",
"the",
"offset",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L123-L128 |
247,298 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_pydoc_documentation | def rpc_get_pydoc_documentation(self, symbol):
"""Get the Pydoc documentation for the given symbol.
Uses pydoc and can return a string with backspace characters
for bold highlighting.
"""
try:
docstring = pydoc.render_doc(str(symbol),
"Elpy Pydoc Documentation for %s",
False)
except (ImportError, pydoc.ErrorDuringImport):
return None
else:
if isinstance(docstring, bytes):
docstring = docstring.decode("utf-8", "replace")
return docstring | python | def rpc_get_pydoc_documentation(self, symbol):
try:
docstring = pydoc.render_doc(str(symbol),
"Elpy Pydoc Documentation for %s",
False)
except (ImportError, pydoc.ErrorDuringImport):
return None
else:
if isinstance(docstring, bytes):
docstring = docstring.decode("utf-8", "replace")
return docstring | [
"def",
"rpc_get_pydoc_documentation",
"(",
"self",
",",
"symbol",
")",
":",
"try",
":",
"docstring",
"=",
"pydoc",
".",
"render_doc",
"(",
"str",
"(",
"symbol",
")",
",",
"\"Elpy Pydoc Documentation for %s\"",
",",
"False",
")",
"except",
"(",
"ImportError",
",",
"pydoc",
".",
"ErrorDuringImport",
")",
":",
"return",
"None",
"else",
":",
"if",
"isinstance",
"(",
"docstring",
",",
"bytes",
")",
":",
"docstring",
"=",
"docstring",
".",
"decode",
"(",
"\"utf-8\"",
",",
"\"replace\"",
")",
"return",
"docstring"
] | Get the Pydoc documentation for the given symbol.
Uses pydoc and can return a string with backspace characters
for bold highlighting. | [
"Get",
"the",
"Pydoc",
"documentation",
"for",
"the",
"given",
"symbol",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L139-L155 |
247,299 | jorgenschaefer/elpy | elpy/server.py | ElpyRPCServer.rpc_get_refactor_options | def rpc_get_refactor_options(self, filename, start, end=None):
"""Return a list of possible refactoring options.
This list will be filtered depending on whether it's
applicable at the point START and possibly the region between
START and END.
"""
try:
from elpy import refactor
except:
raise ImportError("Rope not installed, refactorings unavailable")
ref = refactor.Refactor(self.project_root, filename)
return ref.get_refactor_options(start, end) | python | def rpc_get_refactor_options(self, filename, start, end=None):
try:
from elpy import refactor
except:
raise ImportError("Rope not installed, refactorings unavailable")
ref = refactor.Refactor(self.project_root, filename)
return ref.get_refactor_options(start, end) | [
"def",
"rpc_get_refactor_options",
"(",
"self",
",",
"filename",
",",
"start",
",",
"end",
"=",
"None",
")",
":",
"try",
":",
"from",
"elpy",
"import",
"refactor",
"except",
":",
"raise",
"ImportError",
"(",
"\"Rope not installed, refactorings unavailable\"",
")",
"ref",
"=",
"refactor",
".",
"Refactor",
"(",
"self",
".",
"project_root",
",",
"filename",
")",
"return",
"ref",
".",
"get_refactor_options",
"(",
"start",
",",
"end",
")"
] | Return a list of possible refactoring options.
This list will be filtered depending on whether it's
applicable at the point START and possibly the region between
START and END. | [
"Return",
"a",
"list",
"of",
"possible",
"refactoring",
"options",
"."
] | ffd982f829b11e53f2be187c7b770423341f29bc | https://github.com/jorgenschaefer/elpy/blob/ffd982f829b11e53f2be187c7b770423341f29bc/elpy/server.py#L157-L170 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.