def __onComponentMoodChanged(self, compPxy, mood):
if mood == None: return
if mood in self._neutralMoods: return
if compPxy in self._deleted: return
bag = self.__getComponentBag(compPxy)
if bag == None: return
workerName = compPxy.getRequestedWorkerName()
if compPxy in bag:
if not (mood in self._badMoods):
bag.remove(compPxy)
self.log("Component '%s' not in a bad mood anymore (%s); "
"take out of the bag (worker '%s' bag contains %d components)",
compPxy.label, mood.name, workerName, len(bag))
else:
if mood in self._badMoods:
old = bag.push(compPxy)
self.log("Component '%s' goes in a bad mood (%s); "
"keeping it (worker '%s' bag contains %d components)",
compPxy.label, mood.name, workerName, len(bag))
if old:
self.debug("Worker '%s' disposal bag is full; dumping "
"component '%s'", workerName, old.label)
self._deleted.add(old)
# Let the opportunity to components managers to cleanup,
# but fix a maximum time after which the deletion will be forced
utils.createTimeout(adminconsts.JANITOR_WAIT_FOR_DELETE,
self.__forceComponentDeletion, old)
d = old.forceStop()
# Catch all failures
d.addErrback(defer.resolveFailure)
def __delayedStartComponent(self):
if self._delayed:
self.log("Component startup already scheduled for task '%s'",
self.label)
return
self.log("Scheduling component startup for task '%s'", self.label)
timeout = self.__getRetryDelay()
self._delayed = utils.createTimeout(timeout, self.__startComponent)
def analyse(self, filePath, timeout=None):
deferred = defer.Deferred()
discoverer = Discoverer(filePath,
max_interleave=compconsts.MAX_INTERLEAVE)
discoverer.connect('discovered', self._discoverer_callback)
to = utils.createTimeout(timeout, self.__analyseTimeout, discoverer)
self._pending[discoverer] = (filePath, deferred, to)
discoverer.discover()
return deferred
def __startupPipeline(self, buffer, thumbPath):
assert not self._working
assert self._pipeline != None
self.log("Starting up thumbnailing pipeline '%s'", self._getTranscodingTag())
self._thumbSrc.addBuffer(buffer)
self._fileSink.props.location = thumbPath
ret = self._pipeline.set_state(gst.STATE_PLAYING)
if ret == gst.STATE_CHANGE_FAILURE:
timeout = compconsts.THUMBNAILER_PLAY_ERROR_TIMEOUT
to = utils.createTimeout(timeout, self.__errorNotReceived)
self._playErrorTimeout = to
return
timeout = compconsts.THUMBNAILER_PLAYING_TIMEOUT
to = utils.createTimeout(timeout, self.__playPipelineTimeout)
self._prerollTimeout = to
self._working = True
def _holdLostComponent(self, compPxy):
if self._holdTimeout != None:
return
self.log("Admin task '%s' is holding component '%s'",
self.label, compPxy.getName())
self._onComponentHold(compPxy)
timeout = self.HOLD_TIMEOUT
to = utils.createTimeout(timeout, self.__asyncHoldTimeout,
compPxy)
self._holdTimeout = to
def waitComponentProxy(self, identifier, timeout=None):
"""
Wait to a component with specified identifier.
If it's already contained by the set, the returned
deferred will be called rightaway.
"""
result = defer.Deferred()
if self.hasIdentifier(identifier):
result.callback(self[identifier])
elif self.isIdentifierRejected(identifier):
result.errback(admerrs.ComponentRejectedError("Component rejected"))
else:
to = utils.createTimeout(timeout,
self.__waitComponentTimeout,
identifier, result)
self._compWaiters.setdefault(identifier, {})[result] = to
return result
def __onComponentMoodChanged(self, transPxy, mood):
if not self.isStarted():
return
self.log("Transcoding task '%s' transcoder '%s' goes %s", self.label, transPxy.getName(), mood.name)
if self._isPendingComponent(transPxy):
# Currently beeing started up
return
if self._isElectedComponent(transPxy):
if mood != moods.sad:
utils.cancelTimeout(self._sadTimeout)
if mood == moods.happy:
if self._isHoldingLostComponent():
self._restoreLostComponent(transPxy)
return
if mood == moods.sad:
if not transPxy.isRunning():
# The transcoder has been killed or segfaulted
self._processInterruptionDetected()
self._abort()
return
# The transcoder can be a zombie or waiting for acknowledge.
# Timeout to prevent the task to stall.
timeout = adminconsts.TRANSCODER_SAD_TIMEOUT
to = utils.createTimeout(timeout, self.__asyncSadTimeout, transPxy)
self._sadTimeout = to
return
self.warning(
"Transcoding task '%s' selected transcoder '%s' " "gone %s", self.label, transPxy.getName(), mood.name
)
if mood == moods.lost:
# If the transcoder goes lost, wait a fixed amount of time
# to cope with small transient failures.
self._holdLostComponent(transPxy)
return
self._abort()
if mood == moods.waking:
# Keep the waking components
return
if mood == moods.sleeping:
self._deleteComponent(transPxy)
return
# If no transcoder is selected, don't stop any happy monitor
if (not self._hasElectedComponent()) and (mood == moods.happy):
return
self._stopComponent(transPxy)
def _loadComponent(self, componentType, componentName, componentLabel,
workerPxy, properties, timeout=None):
compId = common.componentId(self._state.get('name'), componentName)
identifier = self.__getComponentUniqueIdByName(componentName)
workerCtx = workerPxy.getWorkerContext()
properties.prepare(workerCtx)
props = properties.asComponentProperties(workerCtx)
resDef = defer.Deferred()
initDef = defer.Deferred()
self._waitCompLoaded[identifier] = initDef
callDef = self._managerPxy._callRemote('loadComponent', componentType,
compId, componentLabel,
props, workerPxy.getName())
to = utils.createTimeout(timeout or adminconsts.LOAD_COMPONENT_TIMEOUT,
self.__asyncComponentLoadedTimeout,
callDef, componentLabel)
args = (identifier, initDef, resDef, to)
callDef.addCallbacks(self.__cbComponentLoaded,
self.__ebComponentLoadingFailed,
callbackArgs=args, errbackArgs=args)
return resDef
def __updateFilesState(self):
if self._stateUpdateDelay or not self._stateUpdateDelta:
return
period = adminconsts.MONITOR_STATE_UPDATE_PERIOD
to = utils.createTimeout(period, self.__doFilesStateUpdate)
self._stateUpdateDelay = to
