def signal(self, sig):
assert self._compState, "Component has been removed"
if not self._workerPxy:
msg = "Component '%s' worker is not running" % self.label
err = admerrs.OrphanComponentError(msg)
return defer.fail(err)
return self._workerPxy._callRemote("killJob", self._getAvatarId(), sig)
def retrieveProfileNotifications(self, profData):
try:
assert isinstance(profData, ImmutableDataWrapper)
d = profData._getData()
assert isinstance(d, dataprops.ProfileData)
result = []
for req in d.notifyFailedRequests:
if req:
result.append(_createReqNotif(profData, False, req))
for req in d.notifyDoneRequests:
if req:
result.append(_createReqNotif(profData, True, req))
params = d.notifyParams
for sql in d.notifyFailedSQL:
if sql:
result.append(_createSQLNotif(profData, False, params, sql))
for sql in d.notifyDoneSQL:
if sql:
result.append(_createSQLNotif(profData, True, params, sql))
recipientsLine = d.notifyFailedMailRecipients
if recipientsLine:
recipients = utils.splitMailRecipients(recipientsLine)
notification = _createMailNotif(profData, False, recipients)
result.append(notification)
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve profile notifications data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def waitUIState(self, timeout=None):
if not self.isRunning():
error = errors.TranscoderError("Cannot retrieve UI state of "
"a non-running component")
return defer.fail(error)
self.__retrieveUIState(timeout)
d = self._waitUIState(timeout)
d.addCallback(defer.overrideResult, self)
return d
def waitActive(self, timeout=None):
"""
Gives a deferred that will be called when the element
has been activated (added)
"""
if self._active:
return defer.succeed(self)
if self._failure:
return defer.fail(self._failure)
return self._activeWaiters.wait(timeout)
def delete(self, *data):
try:
for mutable in data:
if not isinstance(mutable, MutableDataWrapper):
raise NotImplementedError()
mutable._delete()
return defer.succeed(self)
except Exception, e:
error = datasource.DeletionError(cause=e)
return defer.fail(error)
def retrieveCustomers(self):
try:
result = [ImmutableDataWrapper(c, k, hidden=['profiles'])
for k, c in self._customersData.items()
if c != None]
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve customers data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def retrieveCustomerInfo(self, custData):
try:
assert isinstance(custData, ImmutableDataWrapper)
result = ImmutableWrapper((custData.identifier, "info"),
CUST_INFO_TMPL)
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve customer info data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def retrieveTargets(self, profData):
try:
assert isinstance(profData, ImmutableDataWrapper)
result = [ImmutableDataWrapper(t, k, hidden=['config', 'type'])
for k, t in profData._getData().targets.items()
if t != None]
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve targets data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def retrieveProfiles(self, custData):
try:
assert isinstance(custData, ImmutableDataWrapper)
result = [ImmutableDataWrapper(p, k, hidden=['targets'])
for k, p in custData._getData().profiles.items()
if p != None]
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve profiles data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def retrieveDefaults(self):
try:
result = ImmutableDataWrapper(self._adminData, "defaults",
hidden=['customersDir',
'activitiesDir',
'name'])
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve default data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def resume(self, timeout=None):
if not (self._state in [TaskStateEnum.paused,
TaskStateEnum.resuming]):
return defer.fail(errors.TranscoderError("Cannot resume %s if %s"
% (self.label,
self._state.name)))
if self._state == TaskStateEnum.paused:
self.log("Ready to resume task manager '%s'", self.label)
self._state = TaskStateEnum.resuming
self._pauseWaiters.reset()
self._tryStartup()
return self._startWaiters.wait(timeout)
def _childWaitActive(self, timeout=None):
"""
Diffrent than waitActive to ensure calling order.
First the deffered added with waitActive and then
the ones added by _childWaitActive.
Should not be used by child classes, it's realy a private method.
"""
if self._active:
return defer.succeed(self)
if self._failure:
return defer.fail(self._failure)
return self._activeChildWaiters.wait(timeout)
def pause(self, timeout=None):
if not (self._state in [TaskStateEnum.started]):
return defer.fail(errors.TranscoderError("Cannot pause %s if %s"
% (self.label,
self._state.name)))
if self._state == TaskStateEnum.started:
self.log("Pausing task manager '%s'", self.label)
self._state = TaskStateEnum.pausing
# No longer started
self._startWaiters.reset()
self.__pauseTaskManager()
return self._pauseWaiters.wait(timeout)
def process(self):
try:
result = self._doProcessing()
if defer.isDeferred(result):
result.addCallbacks(defer.dropResult, self._targetFailed, callbackArgs=(self._targetDone,))
return result
else:
self._targetDone()
return defer.succeed(self)
except:
f = Failure()
self._targetFailed(f)
return defer.fail(f)
def resume(self, timeout=None):
if self._state == TaskStateEnum.terminated:
# If terminated, a task can be rpaused and resume silently
return defer.succeed(self)
if not (self._state in [TaskStateEnum.paused,
TaskStateEnum.resuming]):
return defer.fail(admerrs.TranscoderError("Cannot resume %s task '%s'"
% (self._state.name,
self.label)))
if self._state == TaskStateEnum.paused:
self.log("Ready to resume admin task '%s'", self.label)
self._state = TaskStateEnum.resuming
self.__startup()
# Resuming and starting is the same for now
return self._startWaiters.wait(timeout)
def pause(self, timeout=None):
if self._state == TaskStateEnum.terminated:
# If terminated, a task can be paused and resume silently
return defer.succeed(self)
if not (self._state in [TaskStateEnum.started]):
return defer.fail(admerrs.TranscoderError("Cannot pause %s task '%s'"
% (self._state.name,
self.label)))
self.log("Pausing admin task '%s'", self.label)
self._state = TaskStateEnum.paused
# No longer have associated worker
self._workerPxy = None
# No longer started
self._startWaiters.reset()
return defer.succeed(self)
def retrieveActivities(self, type, states=None):
try:
assert type in ActivityTypeEnum
states = states and set(states)
result = []
tmpl = _activityTemplateLookup.get(type)
result = [MutableDataWrapper(self, tmpl, p, f, a)
for f, (p, a) in self._activitiesData.items()
if a.type == type]
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve activities data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def start(self, paused=False, timeout=None):
if not (self._state in [TaskStateEnum.stopped,
TaskStateEnum.starting]):
return defer.fail(admerrs.TranscoderError("Cannot start %s task '%s'"
% (self._state.name,
self.label)))
if self._state == TaskStateEnum.stopped:
if paused:
self.log("Starting already paused admin task '%s'",
self.label)
self._state = TaskStateEnum.paused
return defer.succeed(self)
else:
self.log("Ready to start admin task '%s'", self.label)
self._state = TaskStateEnum.starting
self.__startup()
return self._startWaiters.wait(timeout)
def retrieveTargetConfig(self, targData):
try:
assert isinstance(targData, ImmutableDataWrapper)
data = targData._getData()
conf = data.config
if not conf:
# Build a dummy config container. It's only to not have
# an empty config section for identity targets
conf = DummyIdentityConfig()
result = ImmutableDataWrapper(conf, (data.name, "config"),
readonly=['type'])
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve target config data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def retrieveTargetNotifications(self, targData):
try:
assert isinstance(targData, ImmutableDataWrapper)
d = targData._getData()
assert isinstance(d, dataprops.TargetData)
result = []
for req in d.notifyDoneRequests:
if req:
result.append(_createReqNotif(targData, True, req))
params = d.notifyParams
for sql in d.notifyDoneSQL:
if sql:
result.append(_createSQLNotif(targData, True, params, sql))
return defer.succeed(result)
except Exception, e:
msg = "Failed to retrieve target notifications data"
ex = datasource.RetrievalError(msg, cause=e)
f = failure.Failure(ex)
return defer.fail(f)
def stop(self, timeout=None):
"""
Relieve the selected component, and return a deferred that
will be callback with the list of all the components
for the caller to take responsability of.
After this, no component will/should be added or removed.
"""
if self._state in [TaskStateEnum.stopped]:
return defer.fail(admerrs.TranscoderError("Cannot stop %s task '%s'"
% (self._state.name,
self.label)))
self.log("Stopping admin task '%s'", self.label)
self._state = TaskStateEnum.terminated
self.__relieveComponent()
for compPxy in self._compPxys:
self._onComponentRemoved(compPxy)
result = self._compPxys.keys()
self._compPxys.clear()
return defer.succeed(result)
