def process_exception(self, request, exception):
"""
Logs information about the given error
"""
_ = self, request
logger = LogHandler.get('api', 'middleware')
logger.exception('An unhandled exception occurred: {0}'.format(exception))
def __init__(self, ip, username, password):
"""
Initializes the object with credentials and connection information
Requires novaclient library to be installed on the node this code is executed
Uses v2 api in Kilo/Liberty (v1 is deprecated in Kilo/Liberty)
Uses v1_1 api in Juno
"""
try:
from novaclient.v2 import client as nova_client
except ImportError:
from novaclient.v1_1 import client as nova_client
try:
from cinderclient.v2 import client as cinder_client
except ImportError:
from cinderclient.v1 import client as cinder_client
from novaclient import exceptions
self._logger = LogHandler.get('extensions', name='openstack_mgmt')
self._novaclientexceptions = exceptions
self.nova_client = nova_client.Client(username = username,
api_key = password,
project_id = 'admin',
auth_url = 'http://{0}:35357/v2.0'.format(ip),
service_type="compute")
self.cinder_client = cinder_client.Client(username = username,
api_key = password,
project_id = 'admin',
auth_url = 'http://{0}:35357/v2.0'.format(ip),
service_type="volumev2")
self.management = OpenStackManagement(cinder_client = self.cinder_client)
self.STATE_MAPPING = {'up': 'RUNNING'}
self._logger.debug('Init complete')
def new_function(*args, **kwargs):
"""
Wrapped function
"""
request = _find_request(args)
method_args = list(args)[:]
method_args = method_args[method_args.index(request) + 1:]
# Log the call
metadata = {
'meta':
dict((str(key), str(value))
for key, value in request.META.iteritems()),
'request':
dict((str(key), str(value))
for key, value in request.REQUEST.iteritems()),
'cookies':
dict((str(key), str(value))
for key, value in request.COOKIES.iteritems())
}
_logger = LogHandler.get('log', name='api')
_logger.info('[{0}.{1}] - {2} - {3} - {4} - {5}'.format(
f.__module__, f.__name__,
getattr(request, 'client').user_guid if hasattr(
request, 'client') else None, json.dumps(method_args),
json.dumps(kwargs), json.dumps(metadata)))
# Call the function
start = time.time()
return_value = f(*args, **kwargs)
duration = time.time() - start
if duration > 5 and log_slow is True:
logger.warning('API call {0}.{1} took {2}s'.format(
f.__module__, f.__name__, round(duration, 2)))
return return_value
def __init__(self, config_type, vpool_guid, storagedriver_id):
"""
Initializes the class
"""
def make_configure(sct):
"""
section closure
:param sct: Section to create configure function for
"""
return lambda **kwargs: self._add(sct, **kwargs)
if config_type != 'storagedriver':
raise RuntimeError('Invalid configuration type. Allowed: storagedriver')
storagerouterclient.Logger.setupLogging(LogHandler.load_path('storagerouterclient'))
# noinspection PyArgumentList
storagerouterclient.Logger.enableLogging()
self._logger = LogHandler.get('extensions', name='storagedriver')
self.config_type = config_type
self.configuration = {}
self.path = '/ovs/vpools/{0}/hosts/{1}/config/{{0}}'.format(vpool_guid, storagedriver_id)
self.remote_path = 'etcd://127.0.0.1:2379{0}'.format(self.path.format('')).strip('/')
self.is_new = True
self.dirty_entries = []
self.params = copy.deepcopy(StorageDriverConfiguration.parameters) # Never use parameters directly
# Fix some manual "I know what I'm doing" overrides
backend_connection_manager = 'backend_connection_manager'
self.params[self.config_type][backend_connection_manager]['optional'].append('s3_connection_strict_consistency')
# Generate configure_* methods
for section in self.params[self.config_type]:
setattr(self, 'configure_{0}'.format(section), make_configure(section))
def new_function(*args, **kwargs):
"""
Wrapped function
"""
request = _find_request(args)
method_args = list(args)[:]
method_args = method_args[method_args.index(request) + 1:]
# Log the call
metadata = {'meta': dict((str(key), str(value)) for key, value in request.META.iteritems()),
'request': dict((str(key), str(value)) for key, value in request.REQUEST.iteritems()),
'cookies': dict((str(key), str(value)) for key, value in request.COOKIES.iteritems())}
_logger = LogHandler.get('log', name='api')
_logger.info('[{0}.{1}] - {2} - {3} - {4} - {5}'.format(
f.__module__,
f.__name__,
getattr(request, 'client').user_guid if hasattr(request, 'client') else None,
json.dumps(method_args),
json.dumps(kwargs),
json.dumps(metadata)
))
# Call the function
start = time.time()
return_value = f(*args, **kwargs)
duration = time.time() - start
if duration > 5 and log_slow is True:
logger.warning('API call {0}.{1} took {2}s'.format(f.__module__, f.__name__, round(duration, 2)))
return return_value
def new_function(self, request, *args, **kwargs):
"""
Wrapped function
"""
# Log the call
metadata = {
'meta':
dict((str(key), str(value))
for key, value in request.META.iteritems()),
'request':
dict((str(key), str(value))
for key, value in request.REQUEST.iteritems()),
'cookies':
dict((str(key), str(value))
for key, value in request.COOKIES.iteritems())
}
_logger = LogHandler.get('log', name='api')
_logger.info('[{0}.{1}] - {2} - {3} - {4} - {5}'.format(
f.__module__, f.__name__,
getattr(request, 'client').user_guid if hasattr(
request, 'client') else None, json.dumps(list(args)),
json.dumps(kwargs), json.dumps(metadata)))
# Call the function
return f(self, request, *args, **kwargs)
def log_slow_calls(f):
"""
Wrapper to print duration when call takes > 1s
:param f: Function to wrap
:return: Wrapped function
"""
logger = LogHandler.get('extensions', name='etcdconfiguration')
def new_function(*args, **kwargs):
"""
Execute function
:return: Function output
"""
start = time.time()
try:
return f(*args, **kwargs)
finally:
key_info = ''
if 'key' in kwargs:
key_info = ' (key: {0})'.format(kwargs['key'])
elif len(args) > 0:
key_info = ' (key: {0})'.format(args[0])
duration = time.time() - start
if duration > 1:
logger.warning('Call to {0}{1} took {2}s'.format(f.__name__, key_info, duration))
new_function.__name__ = f.__name__
new_function.__module__ = f.__module__
return new_function
def pulse():
"""
Update the heartbeats for all Storage Routers
:return: None
"""
logger = LogHandler.get('extensions', name='heartbeat')
current_time = int(time.time())
machine_id = System.get_my_machine_id()
amqp = '{0}://{1}:{2}@{3}//'.format(EtcdConfiguration.get('/ovs/framework/messagequeue|protocol'),
EtcdConfiguration.get('/ovs/framework/messagequeue|user'),
EtcdConfiguration.get('/ovs/framework/messagequeue|password'),
EtcdConfiguration.get('/ovs/framework/hosts/{0}/ip'.format(machine_id)))
celery_path = OSManager.get_path('celery')
worker_states = check_output("{0} inspect ping -b {1} --timeout=5 2> /dev/null | grep OK | perl -pe 's/\x1b\[[0-9;]*m//g' || true".format(celery_path, amqp), shell=True)
routers = StorageRouterList.get_storagerouters()
for node in routers:
if node.heartbeats is None:
node.heartbeats = {}
if 'celery@{0}: OK'.format(node.name) in worker_states:
node.heartbeats['celery'] = current_time
if node.machine_id == machine_id:
node.heartbeats['process'] = current_time
else:
try:
# check timeout of other nodes and clear arp cache
if node.heartbeats and 'process' in node.heartbeats:
if current_time - node.heartbeats['process'] >= HeartBeat.ARP_TIMEOUT:
check_output("/usr/sbin/arp -d {0}".format(node.name), shell=True)
except CalledProcessError:
logger.exception('Error clearing ARP cache')
node.save()
def manage_running_tasks(tasklist, timesleep=10):
"""
Manage a list of running celery task
- discard PENDING tasks after a certain timeout
- validate RUNNING tasks are actually running
:param tasklist: Dictionary of tasks to wait {IP address: AsyncResult}
:type tasklist: dict
:param timesleep: leep between checks -
-for long running tasks it's better to sleep for a longer period of time to reduce number of ssh calls
:type timesleep: int
:return: results
:rtype: dict
"""
logger = LogHandler.get('lib', name='celery toolbox')
ssh_clients = {}
tasks_pending = {}
tasks_pending_timeout = 1800 # 30 minutes
results = {}
failed_nodes = []
while len(tasklist.keys()) > 0:
for ip, task in tasklist.items():
if task.state in ('SUCCESS', 'FAILURE'):
logger.info('Task {0} finished: {1}'.format(task.id, task.state))
results[ip] = task.get(propagate=False)
del tasklist[ip]
elif task.state == 'PENDING':
if task.id not in tasks_pending:
tasks_pending[task.id] = time.time()
else:
task_pending_since = tasks_pending[task.id]
if time.time() - task_pending_since > tasks_pending_timeout:
logger.warning('Task {0} is pending since {1} on node {2}. Task will be revoked'.format(task.id, datetime.datetime.fromtimestamp(task_pending_since), ip))
revoke(task.id)
del tasklist[ip]
del tasks_pending[task.id]
failed_nodes.append(ip)
elif task.state == 'STARTED':
if ip not in ssh_clients:
ssh_clients[ip] = SSHClient(ip, username='******')
client = ssh_clients[ip]
if ServiceManager.get_service_status('workers', client) is False:
logger.error('Service ovs-workers on node {0} appears halted while there is a task PENDING for it {1}. Task will be revoked.'.format(ip, task.id))
revoke(task.id)
del tasklist[ip]
failed_nodes.append(ip)
else:
ping_result = task.app.control.inspect().ping()
storage_router = StorageRouterList.get_by_ip(ip)
if "celery@{0}".format(storage_router.name) not in ping_result:
logger.error('Service ovs-workers on node {0} is not reachable via rabbitmq while there is a task STARTED for it {1}. Task will be revoked.'.format(ip, task.id))
revoke(task.id)
del tasklist[ip]
failed_nodes.append(ip)
if len(tasklist.keys()) > 0:
time.sleep(timesleep)
return results, failed_nodes
def task_postrun_handler(sender=None, task_id=None, task=None, args=None, kwargs=None, **kwds):
"""
Hook for celery postrun event
"""
_ = sender, task, args, kwargs, kwds
try:
MessageController.fire(MessageController.Type.TASK_COMPLETE, task_id)
except Exception as ex:
loghandler = LogHandler.get('celery', name='celery')
loghandler.error('Caught error during postrun handler: {0}'.format(ex))
def __init__(self, name, wait=None):
"""
Creates a volatile mutex object
"""
self._logger = LogHandler.get('extensions', 'volatile mutex')
self._volatile = VolatileFactory.get_client()
self.name = name
self._has_lock = False
self._start = 0
self._wait = wait
def __init__(self, *args, **kwargs):
"""
Initializes the distributed scheduler
"""
self._logger = LogHandler.get('celery', name='celery beat')
self._persistent = PersistentFactory.get_client()
self._namespace = 'ovs_celery_beat'
self._mutex = volatile_mutex('celery_beat', 10)
self._has_lock = False
super(DistributedScheduler, self).__init__(*args, **kwargs)
self._logger.debug('DS init')
def _log(task, kwargs, storagedriver_id):
"""
Log an event
"""
metadata = {'storagedriver': StorageDriverList.get_by_storagedriver_id(storagedriver_id).guid}
_logger = LogHandler.get('log', name='volumedriver_event')
_logger.info('[{0}.{1}] - {2} - {3}'.format(
task.__class__.__module__,
task.__class__.__name__,
json.dumps(kwargs),
json.dumps(metadata)
))
def _log(task, kwargs, storagedriver_id):
"""
Log an event
"""
metadata = {
'storagedriver':
StorageDriverList.get_by_storagedriver_id(storagedriver_id).guid
}
_logger = LogHandler.get('log', name='volumedriver_event')
_logger.info('[{0}.{1}] - {2} - {3}'.format(task.__class__.__module__,
task.__class__.__name__,
json.dumps(kwargs),
json.dumps(metadata)))
def limit(amount, per, timeout):
"""
Rate-limits the decorated call
"""
logger = LogHandler.get('api', 'oauth2')
def wrap(f):
"""
Wrapper function
"""
def new_function(self, request, *args, **kwargs):
"""
Wrapped function
"""
now = time.time()
key = 'ovs_api_limit_{0}.{1}_{2}'.format(
f.__module__, f.__name__,
request.META['HTTP_X_REAL_IP']
)
client = VolatileFactory.get_client()
mutex = volatile_mutex(key)
try:
mutex.acquire()
rate_info = client.get(key, {'calls': [],
'timeout': None})
active_timeout = rate_info['timeout']
if active_timeout is not None:
if active_timeout > now:
logger.warning('Call {0} is being throttled with a wait of {1}'.format(key, active_timeout - now))
return HttpResponse, {'error_code': 'rate_limit_timeout',
'error': 'Rate limit timeout ({0}s remaining)'.format(round(active_timeout - now, 2))}, 429
else:
rate_info['timeout'] = None
rate_info['calls'] = [call for call in rate_info['calls'] if call > (now - per)] + [now]
calls = len(rate_info['calls'])
if calls > amount:
rate_info['timeout'] = now + timeout
client.set(key, rate_info)
logger.warning('Call {0} is being throttled with a wait of {1}'.format(key, timeout))
return HttpResponse, {'error_code': 'rate_limit_reached',
'error': 'Rate limit reached ({0} in last {1}s)'.format(calls, per)}, 429
client.set(key, rate_info)
finally:
mutex.release()
return f(self, request, *args, **kwargs)
new_function.__name__ = f.__name__
new_function.__module__ = f.__module__
return new_function
return wrap
def __init__(self, host='127.0.0.1', login='******'):
self._logger = LogHandler.get('extensions', name='kvm sdk')
self._logger.debug('Init libvirt')
self.states = {libvirt.VIR_DOMAIN_NOSTATE: 'NO STATE',
libvirt.VIR_DOMAIN_RUNNING: 'RUNNING',
libvirt.VIR_DOMAIN_BLOCKED: 'BLOCKED',
libvirt.VIR_DOMAIN_PAUSED: 'PAUSED',
libvirt.VIR_DOMAIN_SHUTDOWN: 'SHUTDOWN',
libvirt.VIR_DOMAIN_SHUTOFF: 'TURNEDOFF',
libvirt.VIR_DOMAIN_CRASHED: 'CRASHED'}
self.libvirt = libvirt
self.host = host
self.login = login
self._conn = None
self.ssh_client = SSHClient(self.host, username='******')
self._logger.debug('Init complete')
def limit(amount, per, timeout):
"""
Rate-limits the decorated call
"""
logger = LogHandler.get('api')
def wrap(f):
"""
Wrapper function
"""
def new_function(*args, **kwargs):
"""
Wrapped function
"""
request = _find_request(args)
now = time.time()
key = 'ovs_api_limit_{0}.{1}_{2}'.format(
f.__module__, f.__name__,
request.META['HTTP_X_REAL_IP']
)
client = VolatileFactory.get_client()
with volatile_mutex(key):
rate_info = client.get(key, {'calls': [],
'timeout': None})
active_timeout = rate_info['timeout']
if active_timeout is not None:
if active_timeout > now:
logger.warning('Call {0} is being throttled with a wait of {1}'.format(key, active_timeout - now))
raise Throttled(wait=active_timeout - now)
else:
rate_info['timeout'] = None
rate_info['calls'] = [call for call in rate_info['calls'] if call > (now - per)] + [now]
calls = len(rate_info['calls'])
if calls > amount:
rate_info['timeout'] = now + timeout
client.set(key, rate_info)
logger.warning('Call {0} is being throttled with a wait of {1}'.format(key, timeout))
raise Throttled(wait=timeout)
client.set(key, rate_info)
return f(*args, **kwargs)
new_function.__name__ = f.__name__
new_function.__module__ = f.__module__
return new_function
return wrap
def __init__(self, name, wait=None):
"""
Creates a file mutex object
"""
self._logger = LogHandler.get('extensions', 'file mutex')
self.name = name
self._has_lock = False
self._start = 0
self._handle = open(self.key(), 'w')
self._wait = wait
try:
os.chmod(
self.key(),
stat.S_IRUSR | stat.S_IWUSR |
stat.S_IRGRP | stat.S_IWGRP |
stat.S_IROTH | stat.S_IWOTH
)
except OSError:
pass
def new_function(self, request, *args, **kwargs):
"""
Wrapped function
"""
# Log the call
metadata = {'meta': dict((str(key), str(value)) for key, value in request.META.iteritems()),
'request': dict((str(key), str(value)) for key, value in request.REQUEST.iteritems()),
'cookies': dict((str(key), str(value)) for key, value in request.COOKIES.iteritems())}
_logger = LogHandler.get('log', name='api')
_logger.info('[{0}.{1}] - {2} - {3} - {4} - {5}'.format(
f.__module__,
f.__name__,
getattr(request, 'client').user_guid if hasattr(request, 'client') else None,
json.dumps(list(args)),
json.dumps(kwargs),
json.dumps(metadata)
))
# Call the function
return f(self, request, *args, **kwargs)
def new_function(*args, **kwargs):
"""
Wrapped function
"""
# Log the call
if event_type == 'VOLUMEDRIVER_TASK':
metadata = {
'storagedriver':
StorageDriverList.get_by_storagedriver_id(
kwargs['storagedriver_id']).guid
}
else:
metadata = {}
_logger = LogHandler.get('log', name=event_type.lower())
_logger.info('[{0}.{1}] - {2} - {3} - {4}'.format(
f.__module__, f.__name__, json.dumps(list(args)),
json.dumps(kwargs), json.dumps(metadata)))
# Call the function
return f(*args, **kwargs)
def new_function(*args, **kwargs):
"""
Wrapped function
"""
# Log the call
if event_type == 'VOLUMEDRIVER_TASK':
metadata = {'storagedriver': StorageDriverList.get_by_storagedriver_id(kwargs['storagedriver_id']).guid}
else:
metadata = {}
_logger = LogHandler.get('log', name=event_type.lower())
_logger.info('[{0}.{1}] - {2} - {3} - {4}'.format(
f.__module__,
f.__name__,
json.dumps(list(args)),
json.dumps(kwargs),
json.dumps(metadata)
))
# Call the function
return f(*args, **kwargs)
def __init__(self, cinder_client):
self._logger = LogHandler.get('extensions', name='openstack_mgmt')
self.client = SSHClient('127.0.0.1', username='******')
self.cinder_client = cinder_client
self._NOVA_CONF = '/etc/nova/nova.conf'
self._CINDER_CONF = '/etc/cinder/cinder.conf'
self._is_openstack = ServiceManager.has_service(OSManager.get_openstack_cinder_service_name(), self.client)
self._nova_installed = self.client.file_exists(self._NOVA_CONF)
self._cinder_installed = self.client.file_exists(self._CINDER_CONF)
self._driver_location = OSManager.get_openstack_package_base_path()
self._openstack_users = OSManager.get_openstack_users()
self._devstack_driver = '/opt/stack/cinder/cinder/volume/drivers/openvstorage.py'
try:
self._is_devstack = 'stack' in str(self.client.run('ps aux | grep SCREEN | grep stack | grep -v grep || true'))
except SystemExit: # ssh client raises system exit 1
self._is_devstack = False
except Exception:
self._is_devstack = False
try:
from cinder import version
version_string = version.version_string()
if version_string.startswith('9.0'):
self._stack_version = 'newton'
elif version_string.startswith('8.0'):
self._stack_version = 'mitaka'
elif version_string.startswith('2015.2') or version_string.startswith('7.0'):
self._stack_version = 'liberty'
elif version_string.startswith('2015.1'):
self._stack_version = 'kilo'
elif version_string.startswith('2014.2'):
self._stack_version = 'juno'
else:
raise ValueError('Unsupported cinder version: {0}'.format(version_string))
except Exception as ex:
raise ValueError('Cannot determine cinder version: {0}'.format(ex))
def auto_response():
"""
Json response wrapper
"""
logger = LogHandler.get('api', 'oauth2')
def wrap(f):
"""
Wrapper function
"""
def new_function(*args, **kw):
"""
Wrapped function
"""
results = f(*args, **kw)
if isinstance(results, tuple) or isinstance(results, list):
return_type, data = results[0], results[1]
if len(results) == 2:
if isinstance(data, dict):
return return_type(json.dumps(data), content_type='application/json')
return return_type(data)
else:
status_code = results[2]
if isinstance(data, dict):
return return_type(json.dumps(data), content_type='application/json', status=status_code)
return return_type(data, status=status_code)
elif isinstance(results, HttpResponse):
return results
else:
logger.error('Got invalid function return data in auto_reponse')
return HttpResponseServerError()
new_function.__name__ = f.__name__
new_function.__module__ = f.__module__
return new_function
return wrap
from rest_framework.response import Response
from toolbox import Toolbox
from rest_framework.exceptions import PermissionDenied, NotAuthenticated, NotAcceptable, Throttled
from rest_framework import status
from rest_framework.request import Request
from django.core.handlers.wsgi import WSGIRequest
from django.http import Http404
from django.conf import settings
from ovs.dal.exceptions import ObjectNotFoundException
from backend.serializers.serializers import FullSerializer
from ovs.log.logHandler import LogHandler
from ovs.extensions.storage.volatilefactory import VolatileFactory
from ovs.extensions.generic.volatilemutex import VolatileMutex
logger = LogHandler.get('api')
regex = re.compile('^(.*; )?version=(?P<version>([0-9]+|\*)?)(;.*)?$')
def _find_request(args):
"""
Finds the "request" object in args
"""
for item in args:
if isinstance(item, Request) or isinstance(item, WSGIRequest):
return item
def required_roles(roles):
"""
Role validation decorator
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Contains various decorators
"""
import json
from celery.task.control import inspect
from ovs.dal.lists.storagedriverlist import StorageDriverList
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='scheduled tasks')
def log(event_type):
"""
Task logger
"""
def wrap(f):
"""
Wrapper function
"""
def new_function(*args, **kwargs):
"""
Wrapped function
"""
Contains various decorators
"""
import inspect
import json
import random
import string
import time
from ovs.dal.lists.storagedriverlist import StorageDriverList
from ovs.extensions.generic.volatilemutex import VolatileMutex
from ovs.extensions.storage.persistentfactory import PersistentFactory
from ovs.lib.helpers.exceptions import EnsureSingleTimeoutReached
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='scheduled tasks')
ENSURE_SINGLE_KEY = 'ovs_ensure_single'
def log(event_type):
"""
Task logger
:param event_type: Event type
:return: Pointer to function
"""
def wrap(function):
"""
Wrapper function
:param function: Function to log something about
"""
def new_function(*args, **kwargs):
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import time
from subprocess import CalledProcessError
from ovs.extensions.generic.sshclient import SSHClient
from ovs.extensions.generic.system import System
from ovs.extensions.services.service import ServiceManager
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='etcd_installer')
class EtcdInstaller(object):
"""
class to dynamically install/(re)configure etcd cluster
"""
DB_DIR = '/opt/OpenvStorage/db'
DATA_DIR = '{0}/etcd/{1}/data'
WAL_DIR = '{0}/etcd/{1}/wal'
SERVER_URL = 'http://{0}:2380'
CLIENT_URL = 'http://{0}:2379'
MEMBER_REGEX = re.compile(ur'^(?P<id>[^:]+): name=(?P<name>[^ ]+) peerURLs=(?P<peer>[^ ]+) clientURLs=(?P<client>[^ ]+)$')
def __init__(self):
"""
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Module for MgmtCenterController
"""
from ovs.celery_run import celery
from ovs.dal.hybrids.mgmtcenter import MgmtCenter
from ovs.extensions.hypervisor.factory import Factory
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='mgmtcenter')
class MgmtCenterController(object):
"""
Contains all BLL regarding MgmtCenters
"""
@staticmethod
@celery.task(name='ovs.mgmtcenter.test_connection')
def test_connection(mgmt_center_guid):
"""
Test mgmtcenter connection
"""
mgmt_center = MgmtCenter(mgmt_center_guid)
try:
mgmt_center_client = Factory.get_mgmtcenter(
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Debian Package module
"""
import time
from ovs.log.logHandler import LogHandler
from subprocess import check_output
from subprocess import CalledProcessError
logger = LogHandler.get('lib', name='packager')
class DebianPackage(object):
"""
Contains all logic related to Debian packages (used in e.g. Debian, Ubuntu)
"""
OVS_PACKAGE_NAMES = [
'openvstorage', 'openvstorage-core', 'openvstorage-webapps',
'openvstorage-sdm', 'openvstorage-backend',
'openvstorage-backend-core', 'openvstorage-backend-webapps',
'openvstorage-cinder-plugin', 'volumedriver-server',
'volumedriver-base', 'alba', 'arakoon'
]
APT_CONFIG_STRING = '-o Dir::Etc::sourcelist="sources.list.d/ovsaptrepo.list" -o Dir::Etc::sourceparts="-" -o APT::Get::List-Cleanup="0"'
# limitations under the License.
import sys
import os
import time
import subprocess
import shutil
from ovs.extensions.db.arakoon.arakoon.EnsureArakoonWorks import EnsureArakoonWorks
from ovs.extensions.generic.system import System
from ArakoonManagement import ArakoonManagementEx
from ovs.log.logHandler import LogHandler
manager = ArakoonManagementEx()
ensurearakoonworks = EnsureArakoonWorks()
logger = LogHandler.get('arakoon', name='tlogchcker')
class CheckArakoonError(Exception):
def __init__(self, message):
self.message = message
def __speak__(self):
print '{0}'.format(self.message)
class CheckArakoonTlogMark(object):
"""
check if tlogs need marking
mark tlogs that are unmarked
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This script can be used for testing purposes, adding data passed in as the only argument to the
body of a new entry on the queue.
"""
import sys
import pika
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='sender')
if __name__ == '__main__':
data = sys.argv[1] if len(sys.argv) >= 2 else '{}'
queue = sys.argv[2] if len(sys.argv) >= 3 else 'default'
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue=queue, durable=True)
logger.debug('Sending to {0}: {1}'.format(queue, data))
channel.basic_publish(exchange='',
routing_key=queue,
body=data,
# limitations under the License.
import os
import time
import logging
import tempfile
from ConfigParser import RawConfigParser
from ovs.extensions.db.arakoon.ArakoonManagement import ArakoonManagementEx
from ovs.extensions.generic.remote import Remote
from ovs.extensions.generic.sshclient import SSHClient
from ovs.extensions.generic.system import System
from ovs.extensions.services.service import ServiceManager
from StringIO import StringIO
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='arakoon_installer')
logger.logger.propagate = False
class ArakoonNodeConfig(object):
"""
cluster node config parameters
"""
def __init__(self, name, ip, client_port, messaging_port, log_dir, home,
tlog_dir):
"""
Initializes a new Config entry for a single Node
"""
self.name = name
self.ip = ip
self.client_port = client_port
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
File mutex module
"""
import time
import fcntl
import os
import stat
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', 'file mutex')
class NoLockAvailableException(Exception):
"""
Custom exception thrown when lock could not be acquired in due time
"""
pass
class FileMutex(object):
"""
This is mutex backed on the filesystem. It's cross thread and cross process. However
its limited to the boundaries of a filesystem
"""
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Disk module
"""
import re
from subprocess import check_output, CalledProcessError
from ovs.extensions.os.os import OSManager
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='disktools')
class DiskTools(object):
"""
This class contains various helper methods wrt Disk maintenance
"""
@staticmethod
def create_partition(disk_path, disk_size, partition_start,
partition_size):
"""
Creates a partition
:param disk_path: Path of disk device
:type disk_path: str
:param disk_size: Total size of disk
import time
from ovs.log.logHandler import LogHandler
from ovs.extensions.generic.system import System
from ovs.extensions.generic.configuration import Configuration
from ovs.extensions.api.client import OVSClient
from django.views.generic import View
from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse, HttpResponseBadRequest
from django.conf import settings
from oauth2.decorators import auto_response, limit, authenticated
from backend.decorators import required_roles, load
from ovs.dal.lists.bearertokenlist import BearerTokenList
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.dal.lists.backendtypelist import BackendTypeList
logger = LogHandler.get('api', name='metadata')
class MetadataView(View):
"""
Implements retrieval of generic metadata about the services
"""
@auto_response()
@limit(amount=60, per=60, timeout=60)
def get(self, request, *args, **kwargs):
"""
Fetches metadata
"""
_ = args, kwargs
data = {
'authenticated':
from ovs.dal.lists.servicelist import ServiceList
from ovs.dal.lists.servicetypelist import ServiceTypeList
from ovs.dal.lists.vpoollist import VPoolList
from ovs.extensions.db.etcd.configuration import EtcdConfiguration
from ovs.extensions.generic.sshclient import SSHClient
from ovs.extensions.generic.sshclient import UnableToConnectException
from ovs.extensions.generic.system import System
from ovs.extensions.storageserver.storagedriver import MetadataServerClient
from ovs.extensions.storageserver.storagedriver import StorageDriverConfiguration
from ovs.lib.helpers.decorators import ensure_single
from ovs.log.logHandler import LogHandler
from volumedriver.storagerouter import storagerouterclient
from volumedriver.storagerouter.storagerouterclient import MDSMetaDataBackendConfig
from volumedriver.storagerouter.storagerouterclient import MDSNodeConfig
logger = LogHandler.get('lib', name='mds')
storagerouterclient.Logger.setupLogging(
LogHandler.load_path('storagerouterclient'))
storagerouterclient.Logger.enableLogging()
class MDSServiceController(object):
"""
Contains all BLL related to MDSServices
"""
@staticmethod
def prepare_mds_service(storagerouter, vpool, fresh_only, reload_config):
"""
Prepares an MDS service:
* Creates the required configuration
* Sets up the service files
import zlib
import json
import base64
from ovs.celery_run import celery
from ovs.extensions.generic.sshclient import SSHClient, UnableToConnectException
from ovs.extensions.api.client import OVSClient
from ovs.extensions.support.agent import SupportAgent
from ovs.extensions.generic.configuration import Configuration
from ovs.dal.hybrids.license import License
from ovs.dal.lists.licenselist import LicenseList
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.lib.helpers.toolbox import Toolbox
from ovs.lib.helpers.decorators import add_hooks
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='license')
class LicenseController(object):
"""
Validates licenses
"""
@staticmethod
@celery.task(name='ovs.license.validate')
def validate(license_string):
"""
Validates a license with the various components
"""
try:
result = {}
"""
This module contains all code for using the KVM libvirt api
"""
from xml.etree import ElementTree
import subprocess
import os
import glob
import re
import time
import libvirt
from ovs.extensions.generic.sshclient import SSHClient
from ovs.extensions.generic.system import System
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='kvm sdk')
ROOT_PATH = '/etc/libvirt/qemu/' # Get static info from here, or use dom.XMLDesc(0)
RUN_PATH = '/var/run/libvirt/qemu/' # Get live info from here
# Helpers
def _recurse(treeitem):
result = {}
for key, item in treeitem.items():
result[key] = item
for child in treeitem.getchildren():
result[child.tag] = _recurse(child)
for key, item in child.items():
result[child.tag][key] = item
result[child.tag]['<text>'] = child.text
return result
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Module for MgmtCenterController
"""
from ovs.celery_run import celery
from ovs.dal.hybrids.mgmtcenter import MgmtCenter
from ovs.dal.hybrids.pmachine import PMachine
from ovs.extensions.hypervisor.factory import Factory
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='mgmtcenter')
class MgmtCenterController(object):
"""
Contains all BLL regarding MgmtCenters
"""
@staticmethod
@celery.task(name='ovs.mgmtcenter.test_connection')
def test_connection(mgmt_center_guid):
"""
Test management center connection
"""
mgmt_center = MgmtCenter(mgmt_center_guid)
try:
from ovs.dal.hybrids.storagerouter import StorageRouter
from ovs.dal.helpers import Descriptor
import os
import re
import grp
import pwd
import glob
import json
import time
import logging
import tempfile
import paramiko
import socket
logger = LogHandler.get('extensions', name='sshclient')
class UnableToConnectException(Exception):
pass
class SSHClient(object):
"""
Remote/local client
"""
IP_REGEX = re.compile(
'^(((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))$'
)
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Generic system module, executing statements on local node
"""
import os
import uuid
import time
from subprocess import check_output
from ConfigParser import RawConfigParser
from StringIO import StringIO
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='system')
class System(object):
"""
Generic helper class
"""
OVS_ID_FILE = '/etc/openvstorage_id'
my_storagerouter_guid = ''
my_storagedriver_id = ''
def __init__(self):
"""
Dummy init method
# C0111: Missing docstring
# W0142: Used * or ** magic
# R0912: Too many branches
# C0103: Invalid name
# W0212: Access to a protected member
# R0913: Too many arguments
# W0201: Attributed defined outside __init__
# W0231: __init__ method from base class X is not called
# R0903: Too few public methods
# W0223: Method X is abstract in class Y but not overridden
# R0201: Method could be a function
# W0703: Catch "Exception"
# E1121: Too many positional arguments for function call
# R0904: Too many public methods
LOGGER = LogHandler.get('arakoon', 'pyrakoon', propagate=False)
def _validate_signature_helper(fun, *args):
param_native_type_mapping = {
'int': int,
'string': str,
'bool': bool,
}
def validate(arg, arg_type):
if arg_type in param_native_type_mapping:
return isinstance(arg, param_native_type_mapping[arg_type])
elif arg_type == 'string_option':
return isinstance(arg, str) or arg is None
elif arg_type == 'string_list':
"""
import inspect
import json
from celery.task.control import revoke
from ovs.dal.lists.storagedriverlist import StorageDriverList
from ovs.extensions.storage.volatilefactory import VolatileFactory
from ovs.extensions.generic.configuration import Configuration
import volumedriver.storagerouter.FileSystemEvents_pb2 as FileSystemEvents
import volumedriver.storagerouter.VolumeDriverEvents_pb2 as VolumeDriverEvents
from google.protobuf.descriptor import FieldDescriptor
from ovs.log.logHandler import LogHandler
from ovs.lib.vmachine import VMachineController
from ovs.lib.vdisk import VDiskController
logger = LogHandler.get('extensions', name='processor')
CINDER_VOLUME_UPDATE_CACHE = {}
def process(queue, body, mapping):
"""
Processes the actual received body
"""
if queue == Configuration.get('ovs.core.broker.queues.storagedriver'):
cache = VolatileFactory.get_client()
all_extensions = None
message = FileSystemEvents.EventMessage()
message.ParseFromString(body)
])
celery.conf.CELERY_DEFAULT_QUEUE = 'ovs_generic'
celery.conf.CELERY_QUEUES = tuple([
Queue('ovs_generic', routing_key='generic.#'),
Queue('ovs_masters', routing_key='masters.#'),
Queue('ovs_{0}'.format(unique_id),
routing_key='sr.{0}.#'.format(unique_id))
])
celery.conf.CELERY_DEFAULT_EXCHANGE = 'generic'
celery.conf.CELERY_DEFAULT_EXCHANGE_TYPE = 'topic'
celery.conf.CELERY_DEFAULT_ROUTING_KEY = 'generic.default'
celery.conf.CELERY_ACKS_LATE = True # This, together with the below PREFETCH_MULTIPLIER, makes sure that the
celery.conf.CELERYD_PREFETCH_MULTIPLIER = 1 # workers basically won't be prefetching tasks, to prevent deadlocks
celery.conf.CELERYBEAT_SCHEDULE = {}
loghandler = LogHandler.get('celery', name='celery')
@task_postrun.connect
def task_postrun_handler(sender=None,
task_id=None,
task=None,
args=None,
kwargs=None,
**kwds):
"""
Hook for celery postrun event
"""
_ = sender, task, args, kwargs, kwds
MessageController.fire(MessageController.Type.TASK_COMPLETE, task_id)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Middleware module
"""
import re
from django.http import HttpResponse
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('api', 'middleware')
regex = re.compile('^(.*; )?version=(?P<version>([0-9]+|\*)?)(;.*)?$')
class OVSMiddleware(object):
"""
Middleware object
"""
def process_exception(self, request, exception):
"""
Logs information about the given error
"""
_ = self, request
logger.exception('An unhandled exception occurred: {0}'.format(exception))
from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from ovs.dal.lists.mgmtcenterlist import MgmtCenterList
from ovs.dal.hybrids.mgmtcenter import MgmtCenter
from backend.serializers.serializers import FullSerializer
from rest_framework.exceptions import NotAcceptable
from rest_framework.response import Response
from rest_framework import status
from backend.decorators import required_roles, load, return_object, return_list, log
from ovs.log.logHandler import LogHandler
from ovs.lib.mgmtcenter import MgmtCenterController
from celery.exceptions import TimeoutError
logger = LogHandler.get('api', 'mgmtcenters')
class MgmtCenterViewSet(viewsets.ViewSet):
"""
Information about mgmtCenters
"""
permission_classes = (IsAuthenticated, )
prefix = r'mgmtcenters'
base_name = 'mgmtcenters'
@log()
@required_roles(['read'])
@return_list(MgmtCenter)
@load()
def list(self):
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.openvstorage.org/OVS_NON_COMMERCIAL
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import subprocess
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='exportfs')
class Nfsexports(object):
"""
Basic management for /etc/exports
"""
def __init__(self):
self._exports_file = '/etc/exports'
self._cmd = ['/usr/bin/sudo', '-u', 'root', '/usr/sbin/exportfs']
self._restart = ['/usr/bin/sudo', '-u', 'root', '/usr/sbin/exportfs', '-ra']
self._rpcmountd_stop = ['/usr/bin/sudo', '-u', 'root', 'pkill', 'rpc.mountd']
self._rpcmountd_start = ['/usr/bin/sudo', '-u', 'root', '/usr/sbin/rpc.mountd', '--manage-gids']
def _slurp(self):
"""
from ovs.dal.hybrids.vdisk import VDisk
from ovs.dal.lists.vmachinelist import VMachineList
from ovs.dal.lists.pmachinelist import PMachineList
from ovs.dal.lists.vdisklist import VDiskList
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.dal.lists.storagedriverlist import StorageDriverList
from ovs.dal.lists.mgmtcenterlist import MgmtCenterList
from ovs.dal.lists.vpoollist import VPoolList
from ovs.extensions.hypervisor.factory import Factory
from ovs.lib.vdisk import VDiskController
from ovs.lib.messaging import MessageController
from ovs.lib.mdsservice import MDSServiceController
from ovs.log.logHandler import LogHandler
from ovs.extensions.generic.volatilemutex import VolatileMutex
logger = LogHandler.get('lib', name='vmachine')
class VMachineController(object):
"""
Contains all BLL related to VMachines
"""
@staticmethod
@celery.task(name='ovs.machine.create_multiple_from_template')
def create_multiple_from_template(name,
machineguid,
pmachineguids,
start,
amount,
description=None):
pmachine_pointer = 0
# http://www.openvstorage.org/OVS_NON_COMMERCIAL
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Systemd module
"""
from subprocess import CalledProcessError
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='servicemanager')
class Systemd(object):
"""
Contains all logic related to Systemd services
"""
@staticmethod
def _service_exists(name, client, path):
if path is None:
path = '/lib/systemd/system/'
file_to_check = '{0}{1}.service'.format(path, name)
return client.file_exists(file_to_check)
@staticmethod
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Systemd module
"""
from subprocess import CalledProcessError
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='servicemanager')
class Systemd(object):
"""
Contains all logic related to Systemd services
"""
@staticmethod
def _service_exists(name, client, path):
if path is None:
path = '/lib/systemd/system/'
file_to_check = '{0}{1}.service'.format(path, name)
return client.file_exists(file_to_check)
@staticmethod
def _get_name(name, client, path=None):
import re
import os
import time
from subprocess import CalledProcessError
from pyudev import Context
from ovs.celery_run import celery
from ovs.log.logHandler import LogHandler
from ovs.dal.hybrids.diskpartition import DiskPartition
from ovs.dal.hybrids.disk import Disk
from ovs.dal.hybrids.storagerouter import StorageRouter
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.extensions.generic.sshclient import SSHClient, UnableToConnectException
from ovs.extensions.generic.remote import Remote
from ovs.lib.helpers.decorators import ensure_single
logger = LogHandler.get('lib', name='disk')
class DiskController(object):
"""
Contains all BLL wrt physical Disks
"""
@staticmethod
@celery.task(name='ovs.disk.sync_with_reality')
@ensure_single(task_name='ovs.disk.sync_with_reality', mode='CHAINED')
def sync_with_reality(storagerouter_guid=None):
"""
Syncs the Disks from all StorageRouters with the reality.
:param storagerouter_guid: Guid of the Storage Router to synchronize
"""
"""
This module contains all code for using the VMware SOAP API/SDK
"""
from time import sleep
import re
import os
import shutil
from suds.client import Client, WebFault
from suds.cache import ObjectCache
from suds.sudsobject import Property
from suds.plugin import MessagePlugin
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='vmware sdk')
class NotAuthenticatedException(BaseException):
pass
def authenticated(force=False):
"""
Decorator to make that a login is executed in case the current session isn't valid anymore
@param force: Force a (re)login, as some methods also work when not logged in
"""
def wrapper(function):
def new_function(self, *args, **kwargs):
self.__doc__ = function.__doc__
try:
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import subprocess
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='exportfs')
class Nfsexports(object):
"""
Basic management for /etc/exports
"""
def __init__(self):
self._exports_file = '/etc/exports'
self._cmd = ['/usr/bin/sudo', '-u', 'root', '/usr/sbin/exportfs']
self._restart = [
'/usr/bin/sudo', '-u', 'root', '/usr/sbin/exportfs', '-ra'
]
self._rpcmountd_stop = [
'/usr/bin/sudo', '-u', 'root', 'pkill', 'rpc.mountd'
]
# http://www.openvstorage.org/license
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import time
from ovs.extensions.generic.sshclient import SSHClient
from ovs.extensions.generic.system import System
from ovs.extensions.services.service import ServiceManager
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='etcd_installer')
class EtcdInstaller(object):
"""
class to dynamically install/(re)configure etcd cluster
"""
DB_DIR = '/opt/OpenvStorage/db'
DATA_DIR = '{0}/etcd/{1}/data'
WAL_DIR = '{0}/etcd/{1}/wal'
SERVER_URL = 'http://{0}:2380'
CLIENT_URL = 'http://{0}:2379'
MEMBER_REGEX = re.compile(
ur'^(?P<id>[^:]+): name=(?P<name>[^ ]+) peerURLs=(?P<peer>[^ ]+) clientURLs=(?P<client>[^ ]+)$'
)
"""
import re
import os
import time
from subprocess import CalledProcessError
from pyudev import Context
from ovs.celery_run import celery
from ovs.log.logHandler import LogHandler
from ovs.dal.hybrids.diskpartition import DiskPartition
from ovs.dal.hybrids.disk import Disk
from ovs.dal.hybrids.storagerouter import StorageRouter
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.extensions.generic.sshclient import SSHClient, UnableToConnectException
from ovs.extensions.generic.remote import Remote
logger = LogHandler.get('lib', name='disk')
class DiskController(object):
"""
Contains all BLL wrt physical Disks
"""
@staticmethod
@celery.task(name='ovs.disk.sync_with_reality')
def sync_with_reality(storagerouter_guid=None):
"""
Syncs the Disks from all StorageRouters with the reality.
"""
storagerouters = []
if storagerouter_guid is not None:
import zlib
import json
import base64
from ovs.celery_run import celery
from ovs.extensions.generic.sshclient import SSHClient, UnableToConnectException
from ovs.extensions.api.client import OVSClient
from ovs.extensions.support.agent import SupportAgent
from ovs.extensions.db.etcd.configuration import EtcdConfiguration
from ovs.dal.hybrids.license import License
from ovs.dal.lists.licenselist import LicenseList
from ovs.dal.lists.storagerouterlist import StorageRouterList
from ovs.lib.helpers.toolbox import Toolbox
from ovs.lib.helpers.decorators import add_hooks
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('lib', name='license')
class LicenseController(object):
"""
Validates licenses
"""
@staticmethod
@celery.task(name='ovs.license.validate')
def validate(license_string):
"""
Validates a license with the various components
"""
try:
result = {}
data = LicenseController._decode(license_string)
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Generic system module, executing statements on local node
"""
import os
import uuid
import time
from subprocess import check_output
from ConfigParser import RawConfigParser
from StringIO import StringIO
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', name='system')
class System(object):
"""
Generic helper class
"""
OVS_ID_FILE = '/etc/openvstorage_id'
my_storagerouter_guid = ''
my_storagedriver_id = ''
def __init__(self):
"""
Dummy init method
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Memcache store module
"""
import memcache
import re
from threading import Lock
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('extensions', 'memcache store')
def locked():
"""
Locking decorator.
"""
def wrap(f):
"""
Returns a wrapped function
"""
def new_function(self, *args, **kwargs):
"""
Executes the decorated function in a locked context
"""
lock = kwargs.get('lock', True)
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Rpm Package module
"""
import time
from ovs.log.logHandler import LogHandler
from subprocess import check_output
from subprocess import CalledProcessError
logger = LogHandler.get('lib', name='packager')
class RpmPackage(object):
"""
Contains all logic related to Rpm packages (used in e.g. Centos)
"""
OVS_PACKAGE_NAMES = ['openvstorage', 'openvstorage-backend', 'volumedriver-server', 'volumedriver-base', 'alba', 'openvstorage-sdm']
@staticmethod
def _get_version(package_name):
return check_output("yum info {0} | grep Version | cut -d ':' -f 2 || true".format(package_name), shell=True).strip()
@staticmethod
def get_versions():
# limitations under the License.
"""
Contains various decorator
"""
import json
import time
from django.http import HttpResponse, HttpResponseServerError
from django.contrib.auth import authenticate, login
from rest_framework.request import Request
from rest_framework.exceptions import PermissionDenied
from django.core.handlers.wsgi import WSGIRequest
from ovs.extensions.storage.volatilefactory import VolatileFactory
from ovs.extensions.generic.volatilemutex import VolatileMutex
from ovs.log.logHandler import LogHandler
logger = LogHandler.get('api', 'oauth2')
def _find_request(args):
"""
Finds the "request" object in args
"""
for item in args:
if isinstance(item, Request) or isinstance(item, WSGIRequest):
return item
def auto_response():
"""
Json response wrapper
"""
