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