def _authorized():
"""
Indicates whether a call is authenticated
"""
username = Configuration.get("/ovs/alba/asdnodes/{0}/config/main|username".format(NODE_ID))
password = Configuration.get("/ovs/alba/asdnodes/{0}/config/main|password".format(NODE_ID))
auth = request.authorization
return auth and auth.username == username and auth.password == password
def load_config(self, ip=None):
"""
Reads a configuration from reality
"""
if self.filesystem is False:
contents = Configuration.get(self.config_path, raw=True)
else:
client = self._load_client(ip)
contents = client.file_read(self.config_path)
parser = RawConfigParser()
parser.readfp(StringIO(contents))
self.nodes = []
self._extra_globals = {}
for key in parser.options('global'):
if key == 'plugins':
self._plugins = [plugin.strip() for plugin in parser.get('global', 'plugins').split(',')]
elif key == 'cluster_id':
self.cluster_id = parser.get('global', 'cluster_id')
elif key == 'cluster':
pass # Ignore these
else:
self._extra_globals[key] = parser.get('global', key)
for node in parser.get('global', 'cluster').split(','):
node = node.strip()
self.nodes.append(ArakoonNodeConfig(name=node,
ip=parser.get(node, 'ip'),
client_port=parser.get(node, 'client_port'),
messaging_port=parser.get(node, 'messaging_port'),
log_sinks=parser.get(node, 'log_sinks'),
crash_log_sinks=parser.get(node, 'crash_log_sinks'),
home=parser.get(node, 'home'),
tlog_dir=parser.get(node, 'tlog_dir')))
def list_asds(mountpoint):
"""
Lists all ASDs found on a given mountpoint
:param mountpoint: Mountpoint to list ASDs on
:type mountpoint: str
:return: Dictionary of ASDs
:rtype: dict
"""
asds = {}
try:
for asd_id in os.listdir(mountpoint):
if os.path.isdir('/'.join([mountpoint, asd_id])) and Configuration.exists(ASDController.ASD_CONFIG.format(asd_id)):
asds[asd_id] = Configuration.get(ASDController.ASD_CONFIG.format(asd_id))
output, error = ASDController._local_client.run(['ls', '{0}/{1}/'.format(mountpoint, asd_id)], allow_nonzero=True, return_stderr=True)
output += error
if 'Input/output error' in output:
asds[asd_id].update({'state': 'error',
'state_detail': 'io_error'})
continue
service_name = ASDController.ASD_SERVICE_PREFIX.format(asd_id)
if ServiceManager.has_service(service_name, ASDController._local_client):
if ServiceManager.get_service_status(service_name, ASDController._local_client)[0] is False:
asds[asd_id].update({'state': 'error',
'state_detail': 'service_failure'})
else:
asds[asd_id].update({'state': 'ok'})
else:
asds[asd_id].update({'state': 'error',
'state_detail': 'service_failure'})
except OSError as ex:
ASDController._logger.info('Error collecting ASD information: {0}'.format(str(ex)))
return asds
def load_target_definition(source, allow_override=False):
logging_target = {'type': 'console'}
try:
from source.tools.configuration.configuration import Configuration
logging_target = Configuration.get('/ovs/framework/logging')
except:
pass
target_type = logging_target.get('type', 'console')
if allow_override is True and 'OVS_LOGTYPE_OVERRIDE' in os.environ:
target_type = os.environ['OVS_LOGTYPE_OVERRIDE']
if target_type == 'redis':
queue = logging_target.get('queue', '/ovs/logging')
if '{0}' in queue:
queue = queue.format(source)
return {'type': 'redis',
'queue': '/{0}'.format(queue.lstrip('/')),
'host': logging_target.get('host', 'localhost'),
'port': logging_target.get('port', 6379)}
if target_type == 'file':
return {'type': 'file',
'filename': LogHandler.load_path(source)}
return {'type': 'console'}
'asd_ips': (list, Toolbox.regex_ip, False),
'api_port': (int, {'min': 1025, 'max': 65535}, False),
'asd_start_port': (int, {'min': 1025, 'max': 65435}, False)})
except RuntimeError as rte:
print Interactive.boxed_message(['The asd-manager pre-configuration file does not contain correct information\n{0}'.format(rte)])
sys.exit(1)
return config
if __name__ == '__main__':
with open(Toolbox.BOOTSTRAP_FILE, 'r') as bootstrap_file:
node_id = json.load(bootstrap_file)['node_id']
os.environ['ASD_NODE_ID'] = node_id
try:
asd_manager_config = Configuration.get('/ovs/alba/asdnodes/{0}/config/main'.format(node_id))
except:
raise RuntimeError('Configuration management unavailable')
if 'ip' not in asd_manager_config or 'port' not in asd_manager_config:
raise RuntimeError('IP and/or port not available in configuration for ALBA node {0}'.format(node_id))
from source.app import app
@app.before_first_request
def setup_logging():
"""
Configure logging
:return: None
"""
if app.debug is False:
with open(Toolbox.BOOTSTRAP_FILE, 'r') as bootstrap_file:
NODE_ID = json.load(bootstrap_file)['node_id']
os.environ['ASD_NODE_ID'] = NODE_ID
CONFIG_ROOT = '/ovs/alba/asdnodes/{0}/config'.format(NODE_ID)
CURRENT_VERSION = 1
_logger = LogHandler.get('asd-manager', name='post-update')
_logger.info('Executing post-update logic of package openvstorage-sdm')
with file_mutex('package_update_pu'):
client = LocalClient('127.0.0.1', username='******')
key = '{0}/versions'.format(CONFIG_ROOT)
version = Configuration.get(key) if Configuration.exists(key) else 0
service_name = 'asd-manager'
if ServiceManager.has_service(service_name, client) and ServiceManager.get_service_status(service_name, client)[0] is True:
_logger.info('Stopping asd-manager service')
ServiceManager.stop_service(service_name, client)
if version < CURRENT_VERSION:
try:
# Put migration code here
pass
except:
pass
Configuration.set(key, CURRENT_VERSION)
if ServiceManager.has_service(service_name, client) and ServiceManager.get_service_status(service_name, client)[0] is False:
def create_asd(partition_alias):
"""
Creates and starts an ASD on a given disk
:param partition_alias: Alias of the partition of a disk (eg: /dev/disk/by-id/scsi-1ATA_TOSHIBA_MK2002TSKB_92M1KDMHF-part1)
:type partition_alias: str
:return: None
"""
all_asds = {}
mountpoint = None
for alias, mtpt in FSTab.read().iteritems():
all_asds.update(ASDController.list_asds(mtpt))
if alias == partition_alias:
mountpoint = mtpt
if mountpoint is None:
raise RuntimeError('Failed to retrieve the mountpoint for partition with alias: {0}'.format(partition_alias))
# Fetch disk information
disk_size = int(ASDController._local_client.run(['df', '-B', '1', '--output=size', mountpoint]).splitlines()[1])
# Find out appropriate disk size
asds = 1.0
for asd_id in os.listdir(mountpoint):
if os.path.isdir('/'.join([mountpoint, asd_id])) and Configuration.exists(ASDController.ASD_CONFIG.format(asd_id)):
asds += 1
asd_size = int(math.floor(disk_size / asds))
for asd_id in os.listdir(mountpoint):
if os.path.isdir('/'.join([mountpoint, asd_id])) and Configuration.exists(ASDController.ASD_CONFIG.format(asd_id)):
config = json.loads(Configuration.get(ASDController.ASD_CONFIG.format(asd_id), raw=True))
config['capacity'] = asd_size
config['rocksdb_block_cache_size'] = int(asd_size / 1024 / 4)
Configuration.set(ASDController.ASD_CONFIG.format(asd_id), json.dumps(config, indent=4), raw=True)
try:
ServiceManager.send_signal(ASDController.ASD_SERVICE_PREFIX.format(asd_id),
signal.SIGUSR1,
ASDController._local_client)
except Exception as ex:
ASDController._logger.info('Could not send signal to ASD for reloading the quota: {0}'.format(ex))
# Prepare & start service
asd_id = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(32))
ASDController._logger.info('Setting up service for disk {0}'.format(partition_alias))
homedir = '{0}/{1}'.format(mountpoint, asd_id)
base_port = Configuration.get('{0}/network|port'.format(ASDController.CONFIG_ROOT))
ips = Configuration.get('{0}/network|ips'.format(ASDController.CONFIG_ROOT))
used_ports = []
for asd in all_asds.itervalues():
used_ports.append(asd['port'])
if 'rora_port' in asd:
used_ports.append(asd['rora_port'])
asd_port = base_port
rora_port = base_port + 1
while asd_port in used_ports:
asd_port += 1
used_ports.append(asd_port)
while rora_port in used_ports:
rora_port += 1
asd_config = {'home': homedir,
'node_id': ASDController.NODE_ID,
'asd_id': asd_id,
'capacity': asd_size,
'log_level': 'info',
'port': asd_port,
'transport': 'tcp',
'rocksdb_block_cache_size': int(asd_size / 1024 / 4)}
if Configuration.get('/ovs/framework/rdma'):
asd_config['rora_port'] = rora_port
asd_config['rora_transport'] = 'rdma'
if ips is not None and len(ips) > 0:
asd_config['ips'] = ips
if Configuration.exists('{0}/extra'.format(ASDController.CONFIG_ROOT)):
data = Configuration.get('{0}/extra'.format(ASDController.CONFIG_ROOT))
asd_config.update(data)
Configuration.set(ASDController.ASD_CONFIG.format(asd_id), json.dumps(asd_config, indent=4), raw=True)
service_name = ASDController.ASD_SERVICE_PREFIX.format(asd_id)
params = {'CONFIG_PATH': Configuration.get_configuration_path('/ovs/alba/asds/{0}/config'.format(asd_id)),
'SERVICE_NAME': service_name,
'LOG_SINK': LogHandler.get_sink_path('alba_asd')}
os.mkdir(homedir)
ASDController._local_client.run(['chown', '-R', 'alba:alba', homedir])
ServiceManager.add_service('alba-asd', ASDController._local_client, params, service_name)
ASDController.start_asd(asd_id)
