def run(self):
        """
        Run daily search thread
        """
        generic_queue.QueueItem.run(self)
        self.started = True

        try:
            logger.log(u"Beginning daily search for new episodes")
            found_results = search.searchForNeededEpisodes()

            if not found_results:
                logger.log(u"No needed episodes found")
            else:
                for result in found_results:
                    # just use the first result for now
                    if result.seeders not in (-1, None) and result.leechers not in (-1, None):
                        logger.log(u"Downloading {0} with {1} seeders and {2} leechers from {3}".format(result.name,
                                   result.seeders, result.leechers, result.provider.name))
                    else:
                        logger.log(u"Downloading {0} from {1}".format(result.name, result.provider.name))
                    self.success = search.snatchEpisode(result)

                    # give the CPU a break
                    time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])

        except Exception:
            self.success = False
            logger.log(traceback.format_exc(), logger.DEBUG)

        if self.success is None:
            self.success = False

        self.finish()

    def searchForTodaysEpisodes(self):

        self.amActive = True

        self._changeMissingEpisodes()

        # make sure our lists are up to date
        sickbeard.updateAiringList()
        sickbeard.updateComingList()

        with self.lock:
            
            logger.log("Beginning search for new episodes on RSS")

            foundResults = search.searchForNeededEpisodes()
            
            if not len(foundResults):
                logger.log("No needed episodes found on the RSS feeds")
            else:
                for curResult in foundResults:
                    search.snatchEpisode(curResult)
                    time.sleep(2)
                

        # update our lists to reflect any changes we just made
        sickbeard.updateAiringList()
        sickbeard.updateComingList()

        self.amActive = False

    def run(self):
        generic_queue.QueueItem.run(self)

        try:
            self._change_missing_episodes()

            self.update_providers()

            show_list = sickbeard.showList
            fromDate = datetime.date.fromordinal(1)
            for curShow in show_list:
                if curShow.paused:
                    continue

                self.episodes.extend(wantedEpisodes(curShow, fromDate))

            if not self.episodes:
                logger.log(u'No search of cache for episodes required')
                self.success = True
            else:
                num_shows = len(set([ep.show.name for ep in self.episodes]))
                logger.log(u'Found %d needed episode%s spanning %d show%s'
                           % (len(self.episodes), helpers.maybe_plural(len(self.episodes)),
                              num_shows, helpers.maybe_plural(num_shows)))

                try:
                    logger.log(u'Beginning recent search for episodes')
                    found_results = search.searchForNeededEpisodes(self.episodes)

                    if not len(found_results):
                        logger.log(u'No needed episodes found')
                    else:
                        for result in found_results:
                            # just use the first result for now
                            logger.log(u'Downloading %s from %s' % (result.name, result.provider.name))
                            self.success = search.snatchEpisode(result)

                            # give the CPU a break
                            time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])

                except Exception:
                    logger.log(traceback.format_exc(), logger.DEBUG)

                if self.success is None:
                    self.success = False

        finally:
            self.finish()

    def execute(self):
        generic_queue.QueueItem.execute(self)

        self._changeMissingEpisodes()

        logger.log(u"Beginning search for new episodes on RSS")

        foundResults = search.searchForNeededEpisodes()

        if not len(foundResults):
            logger.log(u"No needed episodes found on the RSS feeds")
        else:
            for curResult in foundResults:
                search.snatchEpisode(curResult)
                time.sleep(2)

        generic_queue.QueueItem.finish(self)

    def searchForTodaysEpisodes(self):

        self.amActive = True

        backlogPaused = sickbeard.backlogSearchScheduler.action.amPaused
        if not backlogPaused:
            # pause the backlog to prevent race conditions downloading 2 episodes
            logger.log(u"Pausing backlog so it doesn't collide with episode search", logger.DEBUG)
            sickbeard.backlogSearchScheduler.action.amPaused = True
            while sickbeard.backlogSearchScheduler.action.am_running():
                logger.log(u"Backlog isn't waiting yet, trying again in 1s", logger.DEBUG)
                time.sleep(1)

        logger.log(u"Backlog is stopped, running search now", logger.DEBUG)

        self._changeMissingEpisodes()

        # make sure our lists are up to date
        sickbeard.updateAiringList()
        sickbeard.updateComingList()

        with self.lock:

            logger.log(u"Beginning search for new episodes on RSS")

            foundResults = search.searchForNeededEpisodes()

            if not len(foundResults):
                logger.log(u"No needed episodes found on the RSS feeds")
            else:
                for curResult in foundResults:
                    search.snatchEpisode(curResult)
                    time.sleep(2)


        # update our lists to reflect any changes we just made
        sickbeard.updateAiringList()
        sickbeard.updateComingList()

        if not backlogPaused:
            logger.log(u"Search is done, resuming backlog", logger.DEBUG)
            sickbeard.backlogSearchScheduler.action.amPaused = False
        else:
            logger.log(u"Search is done, leaving backlog paused", logger.DEBUG)

        self.amActive = False

    def execute(self):
        generic_queue.QueueItem.execute(self)

        logger.log("Beginning daily search for [" + self.show.name + "]")
        foundResults = search.searchForNeededEpisodes(self.show, self.segment)

        # reset thread back to original name
        threading.currentThread().name = self.thread_name

        if not len(foundResults):
            logger.log(u"No needed episodes found during daily search for [" + self.show.name + "]")
        else:
            for result in foundResults:
                # just use the first result for now
                logger.log(u"Downloading " + result.name + " from " + result.provider.name)
                search.snatchEpisode(result)

                # give the CPU a break
                time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])

        generic_queue.QueueItem.finish(self)

    def execute(self):
        generic_queue.QueueItem.execute(self)

        self._changeMissingEpisodes()

        logger.log(u"Beginning search for new episodes on RSS")

        foundResults = search.searchForNeededEpisodes()

        if not len(foundResults):
            logger.log(u"No needed episodes found on the RSS feeds")
        else:
            for curResult in foundResults:
                #FUGLY, but it works:
                try:
                    download_dir = curResult.episodes[0].show._location
                except:
                    download_dir = None

                search.snatchEpisode(curResult, download_dir=download_dir)
                time.sleep(2)

        generic_queue.QueueItem.finish(self)

    def process(self, curProvider):
        self._changeMissingEpisodes()

        logger.log(u"Beginning search for new episodes on RSS feeds and in cache")
        return search.searchForNeededEpisodes(curProvider)