def add_maintenance_service(name,
alba_backend_guid,
abm_name,
read_preferences=None):
"""
Add a maintenance service with a specific name
:param name: Name of the maintenance service to add
:type name: str
:param alba_backend_guid: ALBA Backend GUID for which the maintenance service needs to run
:type alba_backend_guid: str
:param abm_name: Name of the ABM cluster
:type abm_name: str
:param read_preferences: List of ALBA Node IDs (LOCAL) or ALBA IDs of linked ALBA Backends (GLOBAL) for the maintenance services where they should prioritize the READ actions
:type read_preferences: list[str]
:return: None
:rtype: NoneType
"""
if MaintenanceController._service_manager.has_service(
name, MaintenanceController._local_client) is False:
alba_pkg_name, alba_version_cmd = PackageFactory.get_package_and_version_cmd_for(
component=PackageFactory.COMP_ALBA)
config_location = '{0}/config'.format(
MaintenanceController.MAINTENANCE_KEY.format(
alba_backend_guid, name))
params = {
'LOG_SINK':
Logger.get_sink_path('alba_maintenance'),
'ALBA_CONFIG':
Configuration.get_configuration_path(config_location),
'ALBA_PKG_NAME':
alba_pkg_name,
'ALBA_VERSION_CMD':
alba_version_cmd
}
Configuration.set(
key=config_location,
value={
'log_level':
'info',
'albamgr_cfg_url':
Configuration.get_configuration_path(
'/ovs/arakoon/{0}/config'.format(abm_name)),
'read_preference':
[] if read_preferences is None else read_preferences,
'multicast_discover_osds':
False
})
MaintenanceController._service_manager.add_service(
name=MaintenanceController.MAINTENANCE_PREFIX,
client=MaintenanceController._local_client,
params=params,
target_name=name)
MaintenanceController._service_manager.start_service(
name, MaintenanceController._local_client)
def create_asd(disk):
"""
Creates and starts an ASD on a given disk
:param disk: Disk on which to create an ASD
:type disk: source.dal.objects.disk.Disk
:return: None
:rtype: NoneType
"""
# Validations
if disk.state == 'MISSING':
raise RuntimeError(
'Cannot create an ASD on missing disk {0}'.format(disk.name))
_node_id = SettingList.get_setting_by_code(code='node_id').value
ipaddresses = Configuration.get('{0}|ips'.format(
ASD_NODE_CONFIG_NETWORK_LOCATION.format(_node_id)))
if len(ipaddresses) == 0:
ipaddresses = OSFactory.get_manager().get_ip_addresses(
client=ASDController._local_client)
if len(ipaddresses) == 0:
raise RuntimeError('Could not find any IP on the local node')
alba_pkg_name, alba_version_cmd = PackageFactory.get_package_and_version_cmd_for(
component='alba'
) # Call here, because this potentially raises error, which should happen before actually making changes
# Fetch disk information
disk_size = int(
ASDController._local_client.run(
['df', '-B', '1', '--output=size', disk.mountpoint],
timeout=5).splitlines()[1])
# Find out appropriate disk size
asd_size = int(math.floor(disk_size / (len(disk.asds) + 1)))
for asd in disk.asds:
if asd.has_config:
config = Configuration.get(asd.config_key)
config['capacity'] = asd_size
cache_size = ASDController.calculate_rocksdb_cache_size(
is_ssd=disk.is_ssd)
if cache_size:
config.update({'rocksdb_block_cache_size': cache_size})
Configuration.set(asd.config_key, config)
try:
ASDController._service_manager.send_signal(
asd.service_name, 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))
used_ports = []
for asd in ASDList.get_asds():
if asd.has_config:
config = Configuration.get(asd.config_key)
used_ports.append(config['port'])
if 'rora_port' in config:
used_ports.append(config['rora_port'])
# Prepare & start service
ASDController._logger.info('Setting up service for disk {0}'.format(
disk.name))
asd_id = ''.join(
random.choice(string.ascii_letters + string.digits)
for _ in range(32))
homedir = '{0}/{1}'.format(disk.mountpoint, asd_id)
base_port = Configuration.get('{0}|port'.format(
ASD_NODE_CONFIG_NETWORK_LOCATION.format(_node_id)))
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 = {
'ips': ipaddresses,
'home': homedir,
'port': asd_port,
'asd_id': asd_id,
'node_id': _node_id,
'capacity': asd_size,
'multicast': None,
'transport': 'tcp',
'log_level': 'info'
}
cache_size = ASDController.calculate_rocksdb_cache_size(
is_ssd=disk.is_ssd)
if cache_size:
asd_config.update({'rocksdb_block_cache_size': cache_size})
if Configuration.get('/ovs/framework/rdma'):
asd_config['rora_port'] = rora_port
asd_config['rora_transport'] = 'rdma'
if Configuration.exists('{0}/extra'.format(
ASD_NODE_CONFIG_LOCATION.format(_node_id))):
data = Configuration.get('{0}/extra'.format(
ASD_NODE_CONFIG_LOCATION.format(_node_id)))
asd_config.update(data)
asd = ASD()
asd.disk = disk
asd.port = asd_port
asd.hosts = ipaddresses
asd.asd_id = asd_id
asd.folder = asd_id
asd.save()
Configuration.set(asd.config_key, asd_config)
params = {
'LOG_SINK': Logger.get_sink_path('alba-asd_{0}'.format(asd_id)),
'CONFIG_PATH':
Configuration.get_configuration_path(asd.config_key),
'SERVICE_NAME': asd.service_name,
'ALBA_PKG_NAME': alba_pkg_name,
'ALBA_VERSION_CMD': alba_version_cmd
}
os.mkdir(homedir)
ASDController._local_client.run(['chown', '-R', 'alba:alba', homedir])
ASDController._service_manager.add_service(
name=ASDController.ASD_PREFIX,
client=ASDController._local_client,
params=params,
target_name=asd.service_name)
ASDController.start_asd(asd)