# Copyright (C) 2011-2014 Red Hat, Inc.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; If not, see <http://www.gnu.org/licenses/>.
#
# Author: tasleson
import hashlib
import os
import unittest
import re
import sys
import syslog
try:
# Python 3.8 required change
from collections.abc import Sequence
except ImportError:
from collections import Sequence
import inspect
try:
from urllib.error import (URLError, HTTPError)
from urllib.parse import urlparse
except ImportError:
from urllib2 import (URLError,
HTTPError)
from urlparse import urlparse
import functools
import traceback
import six
import ssl
import socket
def default_property(name, allow_set=True, doc=None):
"""
Creates the get/set properties for the given name. It assumes that the
actual attribute is '_' + name
TODO: Expand this with domain validation to ensure the values are correct.
"""
attribute_name = '_' + name
def getter(self):
return getattr(self, attribute_name)
def setter(self, value):
setattr(self, attribute_name, value)
prop = property(getter, setter if allow_set else None, None, doc)
def decorator(cls):
setattr(cls, name, prop)
return cls
return decorator
def common_urllib2_error_handler(exp):
if isinstance(exp, HTTPError):
raise LsmError(ErrorNumber.PLUGIN_AUTH_FAILED, str(exp))
if isinstance(exp, URLError):
desc = str(exp)
if 'urlopen error' in desc:
if 'Errno 111' in desc:
raise LsmError(ErrorNumber.NETWORK_CONNREFUSED,
'Connection refused')
if 'Errno 113' in desc:
raise LsmError(ErrorNumber.NETWORK_HOSTDOWN,
'Host is down')
error("Unexpected network error:\n" + traceback.format_exc())
raise LsmError(ErrorNumber.NETWORK_ERROR, desc)
try:
if ssl.CertificateError:
if isinstance(exp, ssl.CertificateError):
raise LsmError(ErrorNumber.NETWORK_ERROR,
"SSL Certificate error (%s)" % str(exp))
except AttributeError:
pass
# Python3 is the gift that keeps on giving!
if six.PY3 and isinstance(exp, ConnectionError):
raise LsmError(ErrorNumber.NETWORK_CONNREFUSED, str(exp))
if isinstance(exp, socket.error):
raise LsmError(ErrorNumber.NETWORK_CONNREFUSED, str(exp))
stack_trace = traceback.format_exc()
error("Unexpected exception:\n" + stack_trace)
raise LsmError(ErrorNumber.PLUGIN_BUG,
"Unexpected exception (TYPE= %s)" % str(type(exp)),
stack_trace)
# Documentation for Proxy class.
#
# Class to encapsulate the actual class we want to call. When an attempt is
# made to access an attribute that doesn't exist we will raise an LsmError
# instead of the default keyError.
class Proxy(object):
"""
Used to provide an unambiguous error when a feature is not implemented.
"""
# The constructor.
# @param self The object self
# @param obj The object instance to wrap
def __init__(self, obj=None):
"""
Constructor which takes an object to wrap.
"""
self.proxied_obj = obj
# Called each time an attribute is requested of the object
# @param self The object self
# @param name Name of the attribute being accessed
# @return The result of the method
def __getattr__(self, name):
"""
Called each time an attribute is requested of the object
"""
if hasattr(self.proxied_obj, name):
return functools.partial(self._present, name)
else:
raise LsmError(ErrorNumber.NO_SUPPORT,
"Unsupported operation")
# Method which is called to invoke the actual method of interest.
# @param self The object self
# @param _proxy_method_name Method to invoke
# @param args Arguments
# @param kwargs Keyword arguments
# @return The result of the method invocation
def _present(self, _proxy_method_name, *args, **kwargs):
"""
Method which is called to invoke the actual method of interest.
"""
return getattr(self.proxied_obj, _proxy_method_name)(*args, **kwargs)
# variable in client and specified on the command line for the daemon
UDS_PATH = '/var/run/lsm/ipc'
# Set to True for verbose logging
LOG_VERBOSE = True
# Constant for byte size
SIZE_CONS = {
'B': 1,
'KiB': 2 ** 10,
'KB': 10 ** 3,
'K': 2 ** 10,
'k': 2 ** 10,
'MiB': 2 ** 20,
'MB': 10 ** 6,
'M': 2 ** 20,
'm': 2 ** 20,
'GiB': 2 ** 30,
'GB': 10 ** 9,
'G': 2 ** 30,
'g': 2 ** 30,
'TiB': 2 ** 40,
'TB': 10 ** 12,
'T': 2 ** 40,
't': 2 ** 40,
'PiB': 2 ** 50,
'PB': 10 ** 15,
'P': 2 ** 50,
'p': 2 ** 50,
'EiB': 2 ** 60,
'EB': 10 ** 18,
'E': 2 ** 60,
'e': 2 ** 60,
}
SIZE_CONS_CHK_LST = ['EiB', 'PiB', 'TiB', 'GiB', 'MiB', 'KiB']
# Converts the size into human format.
# @param size Size in bytes
# @param human True|False
# @return Human representation of size
def sh(size, human=False):
"""
Convert size in bytes to human readable size
The return string will follow IEC binary prefixes, e.g. '1.9 KiB'
For size less than 1024, we do nothing but return the int we get.
TODO: Need a expect to handle when size is not a int. int() might do.
"""
units = None
if human:
for key_name in SIZE_CONS_CHK_LST:
if size >= SIZE_CONS[key_name]:
size /= float(SIZE_CONS[key_name])
units = key_name
break
if not units:
units = "B"
return "%.2f %s" % (size, units)
else:
return size
# Converts the size into human format.
# @param size Size in bytes
# @return Human representation of size in IEC binary size prefixes.
def size_bytes_2_size_human(size):
"""
Convert integer size in bytes to human readable size.
We are following rules of IEC binary prefixes on size:
http://en.wikipedia.org/wiki/Gibibyte
The biggest of unit this function supported is PiB.
The precision is 2 which means you will get '1.99 KiB'
"""
return sh(size, True)
# Converts the size into human format.
# @param size_human Human readable size string, e.g. '1.9 KiB'
# @return Size in bytes
def size_human_2_size_bytes(size_human):
"""
Convert human readable size string into integer size in bytes.
Following rules of IEC binary prefixes on size:
http://en.wikipedia.org/wiki/Gibibyte
Supported input size_human in these formats:
'1.9KiB' # int(1024*1.9)
'1 KiB' # 2**10
'1B' # 1
'2K' # 2*(2**10), treated as '2KiB'
'2k' # 2*(2**10), treated as '2KiB'
'2KB' # 2*(10**3)
"""
regex_size_human = re.compile(r"""
^
([0-9\.]+) # 1: number
[ \t]* # might have space between number and unit
([a-zA-Z]*) # 2: units
$
""", re.X)
regex_match = regex_size_human.match(size_human)
size_bytes = 0
if regex_match:
number = regex_match.group(1)
units = regex_match.group(2)
if not units:
return int(number)
units = units.upper()
units = units.replace('IB', 'iB')
if units in SIZE_CONS:
size_bytes = SIZE_CONS[units] * float(number)
return int(size_bytes)
# Common method used to parse a URI.
# @param uri The uri to parse
# @param requires Optional list of keys that must be present in output
# @param required_params Optional list of required parameters that
# must be present.
# @return A hash of the parsed values.
def uri_parse(uri, requires=None, required_params=None):
"""
Common uri parse method that optionally can check for what is needed
before returning successfully.
"""
try:
rc = {}
u = urlparse(uri)
if u.scheme:
rc['scheme'] = u.scheme
if u.netloc:
rc['netloc'] = u.netloc
if u.port:
rc['port'] = u.port
if u.hostname:
rc['host'] = u.hostname
if u.username:
rc['username'] = u.username
else:
rc['username'] = None
rc['parameters'] = uri_parameters(u)
if requires:
for r in requires:
if r not in rc:
raise LsmError(ErrorNumber.INVALID_ARGUMENT,
'uri missing \"%s\" or is in invalid form' % r)
if required_params:
for r in required_params:
if r not in rc['parameters']:
raise LsmError(ErrorNumber.INVALID_ARGUMENT,
'uri missing query parameter %s' % r)
return rc
except ValueError as ve:
raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"uri invalid: reason: %s" % str(ve))
# Parses the parameters (Query string) of the URI
# @param uri Full uri
# @returns hash of the query string parameters.
def uri_parameters(uri):
# workaround for python bug:
# http://bugs.python.org/issue9374
# for URL: smispy+ssl://admin@emc-smi:5989?namespace=root/emc
# Before the patch committed( RHEL 6 and Fedora 18- ):
# '?namespace=root/emc' is saved in uri.path
# After patched(RHEL 7 and Fedora 19+):
# 'namespace=root/emc' is saved in uri.query
if uri.query:
query = uri.query
elif uri.path:
query = urlparse('http:' + uri[2]).query
else:
return {}
if query:
return dict([part.split('=') for part in query.split('&')])
else:
return {}
# Generates the md5 hex digest of passed in parameter.
# @param t Item to generate signature on.
# @returns md5 hex digest.
def md5(t):
h = hashlib.md5()
h.update(t.encode("utf-8"))
return h.hexdigest()
def int_div(a, b):
# Trying to avoid using past.old_div as we don't have future on all
# platforms we are trying to support
if six.PY3:
return a // b
else:
return a / b
# Converts a list of arguments to string.
# @param args Args to join
# @return string of arguments joined together.
def params_to_string(*args):
return ''.join([str(e) for e in args])
# Unfortunately the process name remains as 'python' so we are using argv[0] in
# the output to allow us to determine which python exe is indeed logging to
# syslog.
# TODO: On newer versions of python this is no longer true, need to fix.
# Posts a message to the syslogger.
# @param level Logging level
# @param prg Program name
# @param msg Message to log.
def post_msg(level, prg, msg):
"""
If a message includes new lines we will create multiple syslog
entries so that the message is readable. Otherwise it isn't very readable.
Hopefully we won't be logging much :-)
"""
for l in msg.split('\n'):
if len(l):
syslog.syslog(level, prg + ": " + l)
def error(*msg):
post_msg(syslog.LOG_ERR, os.path.basename(sys.argv[0]),
params_to_string(*msg))
def info(*msg):
if LOG_VERBOSE:
post_msg(syslog.LOG_INFO, os.path.basename(sys.argv[0]),
params_to_string(*msg))
class SocketEOF(Exception):
"""
Exception class to indicate when we read zero bytes from a socket.
"""
pass
@default_property('code', doc='Error code')
@default_property('msg', doc='Error message')
@default_property('data', doc='Optional error data')
class LsmError(Exception):
def __init__(self, code, message, data=None, *args, **kwargs):
"""
Class represents an error.
"""
Exception.__init__(self, *args, **kwargs)
self._code = code
self._msg = message
self._data = data
def __str__(self):
error_no_str = ErrorNumber.error_number_to_str(self.code)
if self.data is not None and self.data:
return "%s: %s Data: %s" % \
(error_no_str, self.msg, self.data)
else:
return "%s: %s " % (error_no_str, self.msg)
def addl_error_data(domain, level, exception, debug=None, debug_data=None):
"""
Used for gathering additional information about an error.
"""
return {'domain': domain, 'level': level, 'exception': exception,
'debug': debug, 'debug_data': debug_data}
def get_class(class_name):
"""
Given a class name it returns the class, caller will then
need to run the constructor to create.
"""
parts = class_name.split('.')
module = ".".join(parts[:-1])
if len(module):
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
else:
m = __import__('__main__')
m = getattr(m, class_name)
return m
# Note: Some of these don't make sense for python, but they do for other
# Languages so we will be keeping them consistent even though we won't be
# using them.
class ErrorNumber(object):
OK = 0
LIB_BUG = 1
PLUGIN_BUG = 2
JOB_STARTED = 7
TIMEOUT = 11
DAEMON_NOT_RUNNING = 12
PERMISSION_DENIED = 13
NAME_CONFLICT = 50
EXISTS_INITIATOR = 52
INVALID_ARGUMENT = 101
NO_STATE_CHANGE = 125
NETWORK_CONNREFUSED = 140 # Host on network, but connection refused
NETWORK_HOSTDOWN = 141 # Host unreachable on network
NETWORK_ERROR = 142 # Generic network error
NO_MEMORY = 152
NO_SUPPORT = 153
# Deletion related errors
IS_MASKED = 160 # Volume is masked to access group.
HAS_CHILD_DEPENDENCY = 161 # Volume/File system has child dependency.
NOT_FOUND_ACCESS_GROUP = 200
NOT_FOUND_FS = 201
NOT_FOUND_JOB = 202
NOT_FOUND_POOL = 203
NOT_FOUND_FS_SS = 204
NOT_FOUND_VOLUME = 205
NOT_FOUND_NFS_EXPORT = 206
NOT_FOUND_SYSTEM = 208
NOT_FOUND_DISK = 209
NOT_LICENSED = 226
NO_SUPPORT_ONLINE_CHANGE = 250
NO_SUPPORT_OFFLINE_CHANGE = 251
PLUGIN_AUTH_FAILED = 300 # Client supplied credential are incorrect
# Inter-process communication between client & out of process plug-in
# encountered connection errors
PLUGIN_IPC_FAIL = 301
# Incorrect permission on UNIX domain socket used for IPC
PLUGIN_SOCKET_PERMISSION = 307
PLUGIN_NOT_EXIST = 311
NOT_ENOUGH_SPACE = 350
TRANSPORT_COMMUNICATION = 400
TRANSPORT_SERIALIZATION = 401
TRANSPORT_INVALID_ARG = 402
# refuse to remove the last initiator from access group
LAST_INIT_IN_ACCESS_GROUP = 502
UNSUPPORTED_SEARCH_KEY = 510
# volume_mask() will fail if access group has no member/initiator.
EMPTY_ACCESS_GROUP = 511
POOL_NOT_READY = 512 # Pool is not ready for create/resize/etc
DISK_NOT_FREE = 513 # Disk is not in DISK.STATUS_FREE status.
_LOCALS = locals()
@staticmethod
def error_number_to_str(error_no):
for error_str in list(ErrorNumber._LOCALS.keys()):
if ErrorNumber._LOCALS[error_str] == error_no:
return "%s(%d)" % (error_str, error_no)
return "UNKNOWN_ERROR_NUMBER(%d)" % error_no
class JobStatus(object):
INPROGRESS = 1
COMPLETE = 2
ERROR = 3
def type_compare(method_name, exp_type, act_val):
if isinstance(exp_type, Sequence):
if not isinstance(act_val, Sequence):
raise TypeError("%s call is returning a %s, but is "
"expecting a sequence" %
(method_name, str(type(act_val))))
# If the list has only one expected value we will make sure all
# elements in the list adhere to it, otherwise we will enforce a one
# to one check against the expected types.
if len(exp_type) == 1:
for av in act_val:
type_compare(method_name, exp_type[0], av)
else:
# Expect a 1-1 type match, extras get ignored at the moment
for exp, act in zip(exp_type, act_val):
type_compare(method_name, exp, act)
else:
# A number of times a method will return None or some valid type,
# only check on the type if the value is not None
if exp_type != type(act_val) and act_val is not None:
if (isinstance(exp_type, six.string_types) and
isinstance(act_val, six.string_types)):
return
if not inspect.isclass(exp_type) or \
not issubclass(type(act_val), exp_type):
raise TypeError('%s call expected: %s got: %s ' %
(method_name, str(exp_type),
str(type(act_val))))
def return_requires(*types):
"""
Decorator function that allows us to ensure that we are getting the
correct types back from a function/method call.
Note: This is normally frowned upon by the python community, but this API
needs to be language agnostic, so making sure we have the correct types
is quite important.
"""
def outer(func):
@functools.wraps(func)
def inner(*args, **kwargs):
r = func(*args, **kwargs)
# In this case the user did something like
# @return_requires(int, string, int)
# in this case we require that all the args are present.
if len(types) > 1:
if len(r) != len(types):
raise TypeError("%s call expected %d "
"return values, actual = %d" %
(func.__name__, len(types), len(r)))
type_compare(func.__name__, types, r)
elif len(types) == 1:
# We have one return type (but it could be a sequence)
type_compare(func.__name__, types[0], r)
return r
return inner
return outer
class TestCommon(unittest.TestCase):
def setUp(self):
pass
def test_simple(self):
try:
raise SocketEOF()
except SocketEOF as e:
self.assertTrue(isinstance(e, SocketEOF))
try:
raise LsmError(10, 'Message', 'Data')
except LsmError as e:
self.assertTrue(e.code == 10 and e.msg == 'Message' and
e.data == 'Data')
ed = addl_error_data('domain', 'level', 'exception', 'debug',
'debug_data')
self.assertTrue(ed['domain'] == 'domain' and ed['level'] == 'level' and
ed['debug'] == 'debug' and
ed['exception'] == 'exception' and
ed['debug_data'] == 'debug_data')
def tearDown(self):
pass
if __name__ == '__main__':
unittest.main()