def load_allocations(self):
"""Load allocations and assignments map."""
data = self.backend.get_default(z.ALLOCATIONS, default={})
if not data:
return
self.assignments = collections.defaultdict(list)
for obj in data:
partition = obj.get('partition')
name = obj['name']
_LOGGER.info('Loading allocation: %s into partition: %s', name,
partition)
alloc = self.cell.partitions[partition].allocation
for part in re.split('[/:]', name):
alloc = alloc.get_sub_alloc(part)
capacity = resources(obj)
alloc.update(capacity, obj['rank'], obj.get('rank_adjustment'),
obj.get('max_utilization'))
traitz = obj.get('traits', [])
alloc.set_traits(traits.encode(self.trait_codes, traitz))
for assignment in obj.get('assignments', []):
pattern = assignment['pattern'] + '[#]' + ('[0-9]' * 10)
pattern_re = fnmatch.translate(pattern)
key = _alloc_key(pattern)
priority = assignment['priority']
_LOGGER.info('Assignment: %s - %s', pattern, priority)
self.assignments[key].append(
(re.compile(pattern_re), priority, alloc))
def create_server(self, servername, data):
"""Create a new server object from server data."""
label = data.get('partition')
if not label:
# TODO: it will be better to have separate module for constants
# and avoid unnecessary cross imports.
label = admin.DEFAULT_PARTITION
up_since = data.get('up_since', int(time.time()))
traitz = data.get('traits', [])
server = scheduler.Server(servername,
resources(data),
up_since=up_since,
label=label,
traits=traits.encode(self.trait_codes,
traitz))
return server
def load_app(self, appname):
"""Load single application data."""
manifest = self.backend.get_default(z.path.scheduled(appname))
if not manifest:
self.remove_app(appname)
return
priority, allocation = self.find_assignment(appname)
if 'priority' in manifest and int(manifest['priority']) != -1:
priority = int(manifest['priority'])
# TODO: From scheduler perspective it is theoretically
# possible to update data retention timeout.
data_retention = _get_data_retention(manifest)
lease = _get_lease(manifest)
app = self.cell.apps.get(appname, None)
if app:
app.priority = priority
app.data_retention_timeout = data_retention
else:
demand = resources(manifest)
affinity = manifest.get('affinity')
affinity_limits = manifest.get('affinity_limits', None)
identity_group = manifest.get('identity_group')
schedule_once = manifest.get('schedule_once')
traitz = manifest.get('traits', [])
app = scheduler.Application(appname,
priority,
demand,
affinity=affinity,
affinity_limits=affinity_limits,
identity_group=identity_group,
schedule_once=schedule_once,
data_retention_timeout=data_retention,
traits=traits.encode(self.trait_codes,
traitz,
use_invalid=True),
lease=lease)
app.blacklisted = self._is_blacklisted(appname)
self.cell.add_app(allocation, app)
def _transform(codes, trait_list, use_invalid=False, add_new=False):
"""Encode then decode traitz"""
result, new_codes = traits.encode(codes, trait_list, use_invalid, add_new)
return traits.format_traits(new_codes, result)
def _transform(code, traitz, use_invalid=False):
"""Encode then decode traitz"""
return traits.format_traits(code, traits.encode(code, traitz, use_invalid))
def _transform(code, traitz):
"""Encode then decode traitz"""
return traits.format_traits(code, traits.encode(code, traitz))