def __init__(self, name):
WorkSpace.__init__(self, name)
# Initialize shutdown machinery
self.is_shutting_down = False
self.create_standard_var('bye', 'fifo', hidden=True)
# Monitoring
self.agent_tracker = AgentTracker()
self.scoreboard = Scoreboard()
self.__init_monitoring()
# Initialize logging
self.__init_logging()
# Job id
self.__results = ResultQueue()
# Prepare for sleigh plugin version identification
self.__init_version_info()
# Prepare for sentinel keep-alive messages
self.__sentinels = SentinelTracker()
self.__blocked_sentinels = []
self.__init_sentinel_keepalive()
# Prepare for worker/Sentinel registration
self.__registration = WorkerRegistration()
self.__init_worker_reg_variables()
# Prepare the grace period
self.__grace_period_ended = False
# Prepare the join phase machinery
self.__join_phase = JoinPhaseTracker(self.__registration)
self.__init_join_phase()
# Prepare the task queues
self.__task_queue = TaskQueue()
self.__task_by_worker = {}
self.__task_waiters = TaskWaiters(self)
self.__result_waiters = ResultWaiters(self)
self.__init_task_queue()
# Prepare to generate fixedarg IDs
self.__init_fixedarg_id_gen()
class SleighWorkSpace(WorkSpace):
#pylint: disable-msg=R0902,R0904
"""Simple sleigh workspace plugin."""
# Sleigh protocol version 1
PROTO_VERSION = 1
# Plugin priority 20
PRIORITY = 20
def __init__(self, name):
WorkSpace.__init__(self, name)
# Initialize shutdown machinery
self.is_shutting_down = False
self.create_standard_var('bye', 'fifo', hidden=True)
# Monitoring
self.agent_tracker = AgentTracker()
self.scoreboard = Scoreboard()
self.__init_monitoring()
# Initialize logging
self.__init_logging()
# Job id
self.__results = ResultQueue()
# Prepare for sleigh plugin version identification
self.__init_version_info()
# Prepare for sentinel keep-alive messages
self.__sentinels = SentinelTracker()
self.__blocked_sentinels = []
self.__init_sentinel_keepalive()
# Prepare for worker/Sentinel registration
self.__registration = WorkerRegistration()
self.__init_worker_reg_variables()
# Prepare the grace period
self.__grace_period_ended = False
# Prepare the join phase machinery
self.__join_phase = JoinPhaseTracker(self.__registration)
self.__init_join_phase()
# Prepare the task queues
self.__task_queue = TaskQueue()
self.__task_by_worker = {}
self.__task_waiters = TaskWaiters(self)
self.__result_waiters = ResultWaiters(self)
self.__init_task_queue()
# Prepare to generate fixedarg IDs
self.__init_fixedarg_id_gen()
def __get_sentinels(self):
"""Get the sentinel tracker."""
return self.__sentinels
sentinels = property(__get_sentinels)
def __get_registration(self):
"""Get the worker registration structure."""
return self.__registration
registration = property(__get_registration)
def __get_task_queue(self):
"""Get the task queue structure."""
return self.__task_queue
task_queue = property(__get_task_queue)
def __get_join_phase_tracker(self):
"""Get the join phase tracker structure."""
return self.__join_phase
join_phase_tracker = property(__get_join_phase_tracker)
def get_plugin_version(self):
#pylint: disable-msg=R0201,E1101
"""Get plugin version information."""
return get_file_version(__name__, 'sleigh/plugin.py')
def hook_created_ws(self, metadata):
"""Callback from the NWS machinery upon workspace creation. Reads out
relevant options from the metadata.
Parameters:
metadata - metadata passed in at WS creation time
"""
# Set the maximum worker count, if specified
rank_count = metadata.get('rankCount')
if rank_count is not None:
self.registration.max_workers = int(rank_count)
# Start the sentinel waker
sentinel_refresh = float(metadata.get('sentinelRefreshPeriod', '60'))
self.add_periodic_task(sentinel_refresh, self.__wake_sentinels)
# Begin the worker grace period
delay = float(metadata.get('workerGracePeriod', '300'))
self.__schedule_grace_period_end(delay)
def hook_store_pre(self, var, value, metadata):
#pylint: disable-msg=W0613
"""Hook to detect store of 'Sleigh ride over' variable."""
if var.name == 'Sleigh ride over':
self.initiate_shutdown()
#############################################################
## Version info
def __init_version_info(self):
"""Create the version info variables for this workspace."""
self.create_var(Constant('version', SleighWorkSpace.PROTO_VERSION),
hidden=True)
self.create_var(Constant('plugin_version', self.get_plugin_version()))
#############################################################
#############################################################
## Monitoring
def __init_monitoring(self):
"""Create the monitoring variables for this workspace."""
get_report = self.agent_tracker.get_report
self.create_var(simple_metavariable('agentStatus', get_report))
get_score = self.scoreboard.report
self.create_var(simple_metavariable('scoreboard', get_score))
#############################################################
#############################################################
## Logging
def __init_logging(self):
"""Create the logging FIFOs for this workspace."""
self.create_standard_var('logDebug', 'fifo')
self.create_standard_var('logError', 'fifo')
#############################################################
#############################################################
## Grace period
def __schedule_grace_period_end(self, delay):
"""Schedule the end of the grace period for workers. Once the grace
period is over, if we have no workers, we will kill the job."""
call_after_delay(delay, self.__close_grace_period)
def __is_grace_period_over(self):
"""Check if the grace period is over."""
return self.__grace_period_ended
grace_period_over = property(__is_grace_period_over)
def __close_grace_period(self):
"""Close the grace period, killing the job if we have no workers."""
if self.registration.num_registered_workers == 0:
self.initiate_shutdown()
else:
self.__grace_period_ended = True
#############################################################
#############################################################
## Join phase
def __worker_count_fetch(self):
"""Query the number of expected workers, freezing the value so that
future queries return the same value."""
self.registration.freeze_max_workers()
return self.registration.num_expected_workers
def __worker_count_store(self, client, request):
#pylint: disable-msg=W0613
"""Set the number of expected workers, as by a store to the
'workerCount' variable."""
self.registration.max_workers = int(request.value)
def __get_num_actual_workers(self):
"""Get the number of workers that have actually joined the computation
thus far."""
return self.registration.num_registered_workers
num_actual_workers = property(__get_num_actual_workers)
def __disarm_status_var(self, num_workers):
"""Callback on group closure: Change the semantics of the status and
waitForWorkers variables so they don't keep trying to initiate the join
phase."""
new_get = constant_return(Response(value=num_workers))
new_iter = constant_return(([num_workers], 1))
waitforworkers_var = self.get_variable('waitForWorkers')
waitforworkers_var.get_handler = new_get
waitforworkers_var.iter_handler = new_iter
status_var = self.get_variable('status')
status_var.get_handler = new_get
status_var.iter_handler = new_iter
def __mark_deadbeat_workers(self, num_workers):
#pylint: disable-msg=W0613
"""Callback on group closure: Mark as dead any workers which never
reported for duty.
"""
max_workers = self.registration.max_workers
if _DEBUG:
log.msg('Group closed: %d workers max' % max_workers)
for rank in range(max_workers):
if not self.registration.is_worker_registered(rank):
if _DEBUG:
log.msg('Worker %d never reported' % rank)
self.call_hook('deadbeat_worker', rank)
else:
if _DEBUG:
log.msg('Worker %d present' % rank)
def __clear_saved_broadcast_tasks(self, num_workers):
#pylint: disable-msg=W0613
"""Callback on group closure: Clear the list of unassigned broadcast
tasks. (This is a list of all broadcast tasks to date in case another
worker shows up.
"""
self.__task_queue.close_group()
def __is_group_closed(self):
"""Check whether the worker group is closed."""
return self.__join_phase.closed
group_is_closed = property(__is_group_closed)
def hook_dead_worker(self, wrank, worker):
#pylint: disable-msg=W0613
"""Callback invoked when a worker, once active, dies."""
self.initiate_shutdown()
def __wait_for_workers_cb(self, client, request, handler):
"""Schedule a callback to a given client when the result from the
waitForWorkers variable is available.
"""
metadata = request.metadata
delay = float(metadata.get('delay', self.__join_phase.duration))
thunk = lambda: self.__join_phase.wake_waiter(handler,
self.num_actual_workers)
call_after_delay(delay, thunk)
self.__join_phase.add_waiter(handler)
return True
def __status_cb(self, client, request, handler):
"""Schedule a callback to a given client when the result from the
status variable is available.
"""
metadata = request.metadata
delay = float(metadata.get('delay', self.__join_phase.duration))
return self.__join_phase.begin_join_phase(delay, handler)
def __status_store(self, client, request):
#pylint: disable-msg=W0613
"""Handle a store request for either the 'status' or 'waitForWorkers'
variables.
"""
self.__join_phase.duration = float(request.value)
def __init_join_phase(self):
"""Initialize all variables related to the join phase."""
# Create 'waitForWorkers'
var = MetaVariable('waitForWorkers',
constant_return(None),
cb_handler=self.__wait_for_workers_cb)
var.set_handler = self.__status_store
self.create_var(var, hidden=True)
# Create 'status'
var = MetaVariable('status',
constant_return(None),
cb_handler=self.__status_cb)
var.set_handler = self.__status_store
self.create_var(var, hidden=True)
# Create 'join_status'
var = simple_metavariable('join_status', self.__join_phase.get_status)
self.create_var(var)
# Create 'rankCount'
var = simple_metavariable('rankCount', self.__get_num_actual_workers)
self.create_var(var)
# Create 'workerCount'
get_worker_count = self.__worker_count_fetch
var = simple_metavariable('workerCount', get_worker_count)
var.set_handler = self.__worker_count_store
self.create_var(var)
# Attach callbacks for the end of the join phase
cb0 = lambda n_workers: self.call_hook('group_close_pre', n_workers)
cb1 = self.__disarm_status_var
cb2 = self.__mark_deadbeat_workers
cb3 = self.__clear_saved_broadcast_tasks
cb4 = lambda n_workers: self.call_hook('group_close_post', n_workers)
self.__join_phase.add_group_close_callback(cb0)
self.__join_phase.add_group_close_callback(cb1)
self.__join_phase.add_group_close_callback(cb2)
self.__join_phase.add_group_close_callback(cb3)
self.__join_phase.add_group_close_callback(cb4)
#############################################################
#############################################################
## Worker/Sentinel registration subsystem
def __declare_worker(self, conn):
"""Callback activated when the sentinel requests an id for a worker."""
if self.__join_phase.closed:
log.msg(' -> failure (group closed)')
return -1
self.agent_tracker.sentinel_register(conn)
self.registration.register_sentinel(conn)
worker_id = self.registration.allocate_rank(conn)
conn.nwsClientLabel = 'Sentinel %d: %s:%d' % (worker_id,
conn.transport.getPeer().host,
conn.transport.getPeer().port)
self.sentinels.create(conn)
if _DEBUG:
log.msg('Declare worker (sentinel=%s, id=%d)' % \
(str(conn), worker_id))
self.call_hook('declare_worker', conn, worker_id)
return worker_id
def __register_worker(self, conn, worker_id, metadata):
"""Callback activated when a worker reports for duty."""
if _DEBUG:
log.msg('Worker registered (conn=%s, id=%d, metadata=%s)' % \
(str(conn), worker_id, str(metadata)))
if self.__join_phase.closed:
log.msg(' -> failure (group closed)')
raise WorkspaceFailure('Worker registration failed: ' +
'group closed.')
elif self.registration.is_worker_registered(worker_id):
log.msg(" -> failure (worker id already registered)")
raise WorkspaceFailure('Worker registration failed: ' +
'duplicate worker id.')
self.agent_tracker.worker_register(conn)
self.scoreboard.worker_registered(conn)
conn.nwsClientLabel = 'Worker %d: %s:%d' % \
(worker_id,
conn.transport.getPeer().host,
conn.transport.getPeer().port)
self.registration.register_worker(conn, worker_id)
self.get_variable('worker registrations').store(None,
str(worker_id),
metadata)
self.__task_queue.add_worker(conn)
self.call_hook('register_worker', conn, worker_id)
expected = self.registration.num_expected_workers
actual = self.num_actual_workers
if actual == expected:
self.__join_phase.close_group()
log.msg(" -> SUCCESS")
def __worker_id_queue_fetch(self, client, request):
"""Implementation of fetch/find for the 'worker_ids' variable."""
metadata = {}
if request.remove:
new_id = self.__declare_worker(client)
metadata['allocated'] = '1'
else:
new_id = self.registration.get_num_allocated_ranks()
metadata['allocated'] = '0'
return Response(value=str(new_id), metadata=metadata)
def __worker_id_queue_store(self, client, request):
"""Implementation of store for the 'worker_ids' variable."""
worker_id = int(request.value)
worker_metadata = request.metadata
self.__register_worker(client, worker_id, worker_metadata)
def __init_worker_reg_variables(self):
"""Initialze the 'worker_ids' and 'worker registrations' variables."""
# Create 'worker_ids'
iterator_value = self.registration.get_num_allocated_ranks
var = MetaVariable('worker_ids',
self.__worker_id_queue_fetch,
singleton_iter_provider(iterator_value))
var.set_handler = self.__worker_id_queue_store
self.create_var(var, hidden=True)
self.create_standard_var('worker registrations', 'fifo')
def kill_worker(self, rank):
"""Mark a worker as dead and kill the worker. When the worker next
requests a task, it will fail."""
conn = self.registration.get_worker(rank)
if conn is not None:
self.call_hook('dead_worker', rank, conn)
self.agent_tracker.worker_dead(conn)
self.scoreboard.worker_dead(conn)
self.registration.deregister_worker(rank)
self.__task_queue.remove_worker(conn)
self.set_worker_task(conn, None)
self.__task_waiters.cancel_waiter(conn)
def kill_sentinel(self, client):
"""Kill a sentinel, failing all of its workers. Generally only done if
we already suspect the sentinel to be dead. It's really the only
merciful thing to do.
"""
self.agent_tracker.sentinel_dead(client)
self.sentinels.delete(client)
wranks = client.nwsWorkerRanks
for rank in wranks:
self.kill_worker(rank)
#############################################################
#############################################################
## Sentinel keepalive system
def __sentinel_alive(self, conn):
"""Callback activated when a sentinel checks in."""
if conn is not None:
if _DEBUG:
log.msg('Sentinel checked in: %s' % str(conn))
if self.sentinels.update(conn):
return True
else:
log.msg('Sentinel, once declared dead, checked in: %s' %
str(conn))
return False
return False
def __sentinel_alive_fetch(self, client, request):
#pylint: disable-msg=W0613
"""Fetch/find handler for the 'sentinel_alive' variable."""
if not self.is_shutting_down:
if not self.__sentinel_alive(client):
# Dead sentinel. Send a shutdown response.
return Response(value='1')
self.agent_tracker.sentinel_block(client)
return None
else:
# Time to shut down. Send a "shutdown" response.
return Response(value='1')
def __sentinel_alive_iter(self):
"""Iterator handler for the 'sentinel_alive' variable."""
if self.is_shutting_down:
return '1'
else:
return None
def __sentinel_alive_cb(self, client, request, handler):
"""Blocked fetch/find handler for the 'sentinel_alive' variable."""
self.__blocked_sentinels.append(handler)
return True
def __wake_sentinels(self):
"""Wake all of the sentinels."""
if self.is_shutting_down:
reply = Response(value='1')
else:
reply = Response(value='0')
for handler in self.__blocked_sentinels:
handler(reply)
self.__blocked_sentinels = []
self.call_hook('woke_sentinels')
def __init_sentinel_keepalive(self):
"""Initialize the variables required for the sentinel keepalive
subsystem.
"""
# Create 'sentinel_alive'
var = MetaVariable('sentinel_alive',
self.__sentinel_alive_fetch,
self.__sentinel_alive_iter,
cb_handler=self.__sentinel_alive_cb)
self.create_var(var, hidden=True)
#############################################################
#############################################################
## Normal task system
def __register_result(self, jid, value, metadata):
"""Register a result. This will not wake up any result waiters; it
only stores the result in the relevant data structures.
"""
result = (jid, value, dict(metadata))
metadata['batchId'] = jid
self.__results.add_result(jid, result)
def set_worker_task(self, client, task):
"""Set the task assigned to a particular worker."""
if task is None:
if self.__task_by_worker.has_key(client):
del self.__task_by_worker[client]
else:
self.__task_by_worker[client] = task
def __get_job_status(self, jid):
"""Get the status of a particular batch. The status is returned as a
tuple of (num_pending, num_running). Pending includes all tasks which
have been submitted but for which a result has not been produced.
(Thus, all running tasks are also pending tasks.)
"""
pending_count = 0
running_count = 0
criterion = lambda task: task[0] == jid
# Count the current running tasks
for task in self.__task_by_worker.values():
if criterion(task):
pending_count += 1
running_count += 1
# Count the queued tasks
pending_count += self.__task_queue.count_matching(criterion)
return (pending_count, running_count)
def __get_all_job_status(self):
"""Get the status of tasks in the system. The status is returned as a
tuple of (num_pending, num_running). Pending includes all tasks which
have been submitted but for which a result has not been produced.
(Thus, all running tasks are also pending tasks.)
"""
pending_count = len(self.__task_by_worker)
running_count = pending_count
pending_count += self.__task_queue.get_total_count()
return (pending_count, running_count)
def __job_status_fetch(self, client, request):
#pylint: disable-msg=W0613
"""Fetch/find handler for the job_status variable."""
fetch_all = request.metadata.get('all') == '1'
if fetch_all:
status = self.__get_all_job_status()
pending_count, running_count = status
else:
jid = request.metadata.get('batchId')
status = self.__get_job_status(jid)
pending_count, running_count = status
metadata = {'nwsRunning': str(running_count),
'nwsPending': str(pending_count)}
return Response(value=pending_count, metadata=metadata)
def submit_unicast(self, task):
"""Submit a unicast task, waking waiters."""
self.__task_queue.add_unicast(task)
self.__task_waiters.wake_one()
def __task_queue_store(self, client, request):
"""Store handler for the task queue variable."""
if self.is_shutting_down:
raise WorkspaceFailure('Store failed: sleigh is shutting down.',
5001)
# Build the task
data = request.value
metadata = request.metadata
jid = metadata.get('batchId')
task = _assemble_task(data, metadata, jid, False)
# Now submit it
self.call_hook('new_unicast_pre', client, task)
self.submit_unicast(task)
self.call_hook('new_unicast_post', client, task)
def task_queue_fetch(self, client, request):
"""Fetch/find handler for the task queue variable."""
if self.is_shutting_down:
raise OperationFailure('sleigh is dead')
if not request.remove:
raise OperationFailure('find is not supported on the task queue')
task = self.__task_queue.fetch_next_task(client)
if task is not None:
self.agent_tracker.worker_gottask(client)
self.scoreboard.worker_tooktask(client)
jid, val, metadata, _ = task
self.set_worker_task(client, task)
self.call_hook('assign_task', client, task)
metadata['batchId'] = jid
return Response(value=val, metadata=metadata)
else:
return None
def __task_queue_iter(self):
#pylint: disable-msg=W0613
"""Iterator handler for the task queue variable."""
length = self.__task_queue.get_total_count()
iterator = itertools.repeat('Opaque task data', length)
return iterator, length
def __task_queue_cb(self, client, request, handler):
"""Blocked fetch/find handler for the task queue variable."""
self.agent_tracker.worker_block(client)
self.__task_waiters.add_waiter(client, request, handler)
return True
def __broadcast_task_queue_store(self, client, request):
"""Store handler for the 'broadcast' variable."""
data = request.value
metadata = request.metadata
jid = metadata.get('batchId')
task = _assemble_task(data, metadata, jid, True)
# Sending a broadcast task initiates a join phase
if not self.__join_phase.closed:
self.__join_phase.request_group_close()
# Add to the task queues and wake the waiters
self.call_hook('new_broadcast_pre', client, task)
self.__task_queue.add_broadcast(task)
self.__task_waiters.wake_all()
self.call_hook('new_broadcast_post', client, task)
def __broadcast_task_queue_fetch(self, client, request):
#pylint: disable-msg=W0613,R0201
"""Fetch/find handler for the 'broadcast' variable."""
return Response(value=0)
def __result_queue_store(self, client, request):
"""Store handler for the results queue variable."""
jid, _, task_metadata, _ = self.__task_by_worker[client]
task_metadata.update(request.metadata)
task_metadata['batchId'] = jid
task_metadata['nwsWorkerRank'] = str(client.nwsWorkerRank)
self.call_hook('finish_task_pre', client,
jid, request.value, task_metadata)
self.set_worker_task(client, None)
self.agent_tracker.worker_returnedresult(client)
self.scoreboard.worker_finishedtask(client)
self.__register_result(jid, request.value, task_metadata)
self.__result_waiters.wake_one(jid)
self.call_hook('finish_task_post', client,
jid, request.value, task_metadata)
def result_queue_fetch(self, client, request):
"""Fetch/find handler for the results queue variable."""
if self.is_shutting_down:
raise OperationFailure('sleigh is dead')
# Try to find the right result
jid = request.metadata.get('batchId')
result = self.__results.get_result(jid)
if result is None:
return None
# Update stats
self.agent_tracker.master_gotresult(client)
_, data, metadata = result
return Response(value=data, metadata=metadata)
def __result_queue_iter(self):
#pylint: disable-msg=W0613
"""Iterator handler for the results queue variable."""
length = self.__results.get_total_count()
iterator = itertools.repeat('Opaque result data', length)
return iterator, length
def __result_queue_cb(self, client, request, handler):
"""Blocked fetch/find handler for the results queue variable."""
jid = request.metadata.get('batchId')
self.agent_tracker.master_awaitresult(client)
self.__result_waiters.add_waiter(jid, client, request, handler)
return True
def put_result(self, jid, resp, wrank):
"""Synthesize a result to the task currently claimed by the worker
whose rank is wrank.
"""
if resp is None:
resp = Response(value='', metadata={'nwsNull': '1'})
resp.metadata['nwsWorkerRank'] = str(wrank)
self.__register_result(jid, resp.value, resp.metadata)
self.__result_waiters.wake_one(jid)
def get_worker_task(self, worker):
"""Get the task which is currently assigned to the given worker."""
return self.__task_by_worker.get(worker)
def __init_task_queue(self):
"""Initialize all variables related to the task queue and result
queue.
"""
# Create 'task' variable
var = MetaVariable('task',
self.task_queue_fetch,
self.__task_queue_iter,
self.__task_queue_cb)
var.set_handler = self.__task_queue_store
var.unwrap_stores = False
self.create_var(var)
# Create 'result' variable
var = MetaVariable('result',
self.result_queue_fetch,
self.__result_queue_iter,
self.__result_queue_cb)
var.set_handler = self.__result_queue_store
var.unwrap_stores = False
self.create_var(var)
# Create 'jobStatus' variable
iterfunc = lambda: self.__get_all_job_status()[0]
var = MetaVariable('jobStatus',
self.__job_status_fetch,
singleton_iter_provider(iterfunc))
self.create_var(var, hidden=True)
# Create 'broadcast' variable
var = MetaVariable('broadcast',
self.__broadcast_task_queue_fetch)
var.set_handler = self.__broadcast_task_queue_store
var.unwrap_stores = False
self.create_var(var, hidden=True)
#############################################################
#############################################################
## Fixedarg system
def __init_fixedarg_id_gen(self):
"""Create fixedargID generator variable."""
self.fixedArgVal=0
var = MetaVariable('fixedargID',
self.__fixedargID_fetch,
singleton_iter_provider(self.__fixedargID_get_cur))
self.create_var(var,hidden=True)
def __fixedargID_get_cur(self):
return self.fixedArgVal
def __fixedargID_fetch(self,x,y):
self.fixedArgVal+=1
self.create_standard_var("#fixedArg"+str(self.fixedArgVal),'single',
hidden=True)
return Response(value="#fixedArg"+str(self.fixedArgVal))
#############################################################
#############################################################
## Shutdown system
def initiate_shutdown(self):
"""Initiate shutdown mode."""
self.is_shutting_down = True
self.__wake_sentinels()
self.__result_waiters.kill_all()
