startstoprulesdefaultplugin.java

Azureus is a powerful, full-featured, cross-platform java BitTorrent client

      DownloadStats stats = dl.getStats();
      int state = dl.getState();
      // Timed torrents don't use a speed threshold, since they are based on time!
      // However, First Priorities need to be checked for activity so that 
      // timed ones can start when FPs are below threshold.  Ditto for 0 Peers
      // when bAutoStart0Peers
      if (iRankType == RANK_TIMED && !isFirstPriority() &&
          !(bAutoStart0Peers && calcPeersNoUs(dl) == 0 && scrapeResultOk(dl))) {
        return (state == Download.ST_SEEDING);
      }

      // In order to be active,
      // - Must be seeding
      // - Must be above speed threshold, or started less than 30s ago
      // - If we auto-start 0 Peers, must not have 0 Peers
      if ((state == Download.ST_SEEDING) &&
          ((stats.getUploadAverage() >= minSpeedForActiveSeeding) ||
           (SystemTime.getCurrentTime() - stats.getTimeStarted() <= FORCE_ACTIVE_FOR)) &&
          (!bAutoStart0Peers || calcPeersNoUs(dl) > 0))
        bIsActive = true;

      if (bActivelySeeding != bIsActive) {
        bActivelySeeding = bIsActive;
        somethingChanged = true;
        if (bDebugLog) 
          log.log(LoggerChannel.LT_INFORMATION,
                  "somethingChanged: ActivelySeeding changed for " + dl.getName());
      }
      return bActivelySeeding;
    }
    
    public boolean getIsSeeding() {
      int state = dl.getState();
      if (state == Download.ST_SEEDING)
        return true;
      return (dl.getStats().getDownloadCompleted(false) == 1000 &&
               (state == Download.ST_READY ||
                state == Download.ST_WAITING ||
                state == Download.ST_PREPARING));
    }

    public boolean getIsDownloading() {
      int state = dl.getState();
      if (state == Download.ST_DOWNLOADING)
        return true;
      return (dl.getStats().getDownloadCompleted(false) < 1000 &&
               (state == Download.ST_READY ||
                state == Download.ST_WAITING ||
                state == Download.ST_PREPARING));
    }

    public int getSeedingRank() {
      return sr;
    }

    public void setSeedingRank(int newSeedingRank) {
      sr = newSeedingRank;
    }

    /** Assign Seeding Rank based on RankType
     * @return New Seeding Rank Value
     */
    public int 
	recalcSeedingRank() 
    {
    	try{
    		downloadData_this_mon.enter();
    	
	      DownloadStats stats = dl.getStats();
	      int numCompleted = stats.getDownloadCompleted(false);
	
	      	// make undownloaded sort to top so they start can first.
	      
	      if (numCompleted < 1000) {
	        setSeedingRank(SR_INCOMPLETE_ENDS_AT - dl.getPosition());
	        return sr;
	      }
	
	      	// here we are seeding
	      
	      int shareRatio = stats.getShareRatio();
	
	      int num_peers_excluding_us = calcPeersNoUs(dl);
	      int num_seeds_excluding_us = calcSeedsNoUs(dl);
	      
	      if (numPeersAsFullCopy != 0 && num_seeds_excluding_us >= iFakeFullCopySeedStart){
	      	
	          num_seeds_excluding_us += num_peers_excluding_us / numPeersAsFullCopy;
	      }
	      
	      boolean bScrapeResultsOk = (num_peers_excluding_us > 0) || (num_seeds_excluding_us > 0) || scrapeResultOk(dl);
	
	      int newSR = 0;
	
	      if (isFirstPriority()){
	      	
	        newSR = SR_FIRST_PRIORITY_STARTS_AT;
	        
	      }else{
	      
		      /** 
		       * Check ignore rules
		       */
		      // never apply ignore rules to First Priority Matches
		      // (we don't want leechers circumventing the 0.5 rule)
	      
	        if (num_peers_excluding_us == 0 && bScrapeResultsOk && bIgnore0Peers) {
	          setSeedingRank(SR_0PEERS);
	          return SR_0PEERS;
	        }
	
	        if (iIgnoreShareRatio != 0 && 
	            shareRatio > iIgnoreShareRatio && 
	            num_seeds_excluding_us >= iIgnoreShareRatio_SeedStart &&
	            shareRatio != -1) {
	          setSeedingRank(SR_SHARERATIOMET);
	          return sr;
	        }
	  
	        //0 means disabled
	        if ((iIgnoreSeedCount != 0) && (num_seeds_excluding_us >= iIgnoreSeedCount)) {
	          setSeedingRank(SR_NUMSEEDSMET);
	          return SR_NUMSEEDSMET;
	        }
	
	        // Skip if Stop Peers Ratio exceeded
	        // (More Peers for each Seed than specified in Config)
	        //0 means never stop
	        if (iIgnoreRatioPeers != 0 && num_seeds_excluding_us != 0) {
	          float ratio = (float) num_peers_excluding_us / num_seeds_excluding_us;
	          if (ratio <= iIgnoreRatioPeers && num_seeds_excluding_us >= iIgnoreRatioPeers_SeedStart) {
	            setSeedingRank(SR_RATIOMET);
	            return SR_RATIOMET;
	          }
	        }
	      }
	
	      
	      // Never do anything with rank type of none
	      if (iRankType == RANK_NONE) {
	        // everythink ok!
	        setSeedingRank(newSR);
	        return newSR;
	      }
	
	      if (iRankType == RANK_TIMED) {
	        if (newSR >= SR_FIRST_PRIORITY_STARTS_AT) {
	          setSeedingRank(newSR);
	          return newSR;
	        }
	
	        int state = dl.getState();
	        if (state == Download.ST_STOPPING ||
	            state == Download.ST_STOPPED ||
	            state == Download.ST_ERROR) {
	          setSeedingRank(SR_NOTQUEUED);
	          return SR_NOTQUEUED;
	        } else if (state == Download.ST_SEEDING ||
	                   state == Download.ST_READY ||
	                   state == Download.ST_WAITING ||
	                   state == Download.ST_PREPARING) {
	          // force sort to top
	          long lMsElapsed = 0;
	          if (state == Download.ST_SEEDING && !dl.isForceStart())
	            lMsElapsed = (SystemTime.getCurrentTime() - stats.getTimeStartedSeeding());
	
	          int oldSR = getSeedingRank();
	          if (lMsElapsed >= minTimeAlive) {
	            setSeedingRank(1);
	            if (oldSR > SR_TIMED_QUEUED_ENDS_AT) {
	              somethingChanged = true;
	              if (bDebugLog) 
	                log.log(LoggerChannel.LT_INFORMATION,
	                        "somethingChanged: TimeUp for " + dl.getName());
	            }
	          } else {
	            setSeedingRank(SR_TIMED_QUEUED_ENDS_AT + 1 + (int)(lMsElapsed/1000));
	            if (oldSR <= SR_TIMED_QUEUED_ENDS_AT) {
	              somethingChanged = true;
	              if (bDebugLog) 
	                log.log(LoggerChannel.LT_INFORMATION,
	                        "somethingChanged: strange timer change for " + dl.getName());
	            }
	          }
	          return getSeedingRank();
	        } else {
	          if (getSeedingRank() <= 0) {
	            setSeedingRank(SR_TIMED_QUEUED_ENDS_AT - dl.getPosition());
	            somethingChanged = true;
	            if (bDebugLog) 
	              log.log(LoggerChannel.LT_INFORMATION,
	                      "somethingChanged: NotIgnored for " + dl.getName());
	          }
	          return getSeedingRank();
	        }
	      }
	
	
	
	      /** 
	       * Add to SeedingRank based on Rank Type
	       */
	
	      if ((iRankType == RANK_SEEDCOUNT) && 
	          (iRankTypeSeedFallback == 0 || iRankTypeSeedFallback > num_seeds_excluding_us))
	      {
	        if (bScrapeResultsOk) {
	          int limit = SR_FIRST_PRIORITY_STARTS_AT / 2 - 10000;
	          newSR += limit/(num_seeds_excluding_us + 1) +
	                   ((bPreferLargerSwarms ? 1 : -1) * num_peers_excluding_us * 5);
	          if (num_seeds_excluding_us == 0 && num_peers_excluding_us >= minPeersToBoostNoSeeds)
	            newSR += limit;
	        }
	
	      } else { // iRankType == RANK_SPRATIO or we are falling back
	        if (num_peers_excluding_us != 0) {
	          if (num_seeds_excluding_us == 0) {
	            if (num_peers_excluding_us >= minPeersToBoostNoSeeds)
	              newSR += 20000;
	          }
	          else { // numSeeds != 0 && numPeers != 0
	            if (num_peers_excluding_us > num_seeds_excluding_us) {
	              // give poor seeds:peer ratio a boost 
	              newSR += 10000 - (num_seeds_excluding_us * 10000 / num_peers_excluding_us);
	            }
	            else { // Peers <= Seeds
	              newSR += num_peers_excluding_us * 1000 / num_seeds_excluding_us;
	            }
	          }
	
	          if (bPreferLargerSwarms)
	            newSR += num_peers_excluding_us * 5;
	          else
	            newSR -= num_peers_excluding_us * 5;
	        }
	      }
	
	      if (newSR < 0)
	        newSR = 1;
	
	      // Don't change the SeedingRank if we don't have scrape results
	      // unless we changed to first priority
	      boolean bOldSRInRange = (sr >= 0) && (sr < SR_FIRST_PRIORITY_STARTS_AT);
	      boolean bNewSRInRange = (newSR >= 0) && (newSR < SR_FIRST_PRIORITY_STARTS_AT);
	      if (bScrapeResultsOk || bOldSRInRange != bNewSRInRange)
	        setSeedingRank(newSR);
	
	      return sr;
	      
    	}finally{
    		
    		downloadData_this_mon.exit();
    	}
    } // recalcSeedingRank

    /** Does the torrent match First Priority criteria? */
    public boolean isFirstPriority() {
      if (bDebugLog) sExplainFP = "FP Calculations.  Using " + 
                                  (iFirstPriorityType == FIRSTPRIORITY_ALL ? "All": "Any") + 
                                  ":\n";
      
      if (!dl.isPersistent()) {
        if (bDebugLog) sExplainFP += "Not FP: Download not persistent\n";
        return false;
      }

      // FP only applies to completed
      if (dl.getStats().getDownloadCompleted(false) < 1000) {
        if (bDebugLog) sExplainFP += "Not FP: Download not complete\n";
        return false;
      }

      if (dl.getState() == Download.ST_ERROR ||
          dl.getState() == Download.ST_STOPPED) {
        if (bDebugLog) sExplainFP += "Not FP: Download is ERROR or STOPPED\n";
        return false;
      }
      
      // FP doesn't apply when S:P >= 10:1
      int numPeers = calcPeersNoUs(dl);
      int numSeeds = calcSeedsNoUs(dl);
      if (numPeers > 0 && numSeeds > 0 && (numSeeds / numPeers) >= 10) {
        if (bDebugLog) sExplainFP += "Not FP: P:S >= 10:1\n";
        return false;
      }

      //not FP if no peers  //Nolar, 2105
      if( numPeers == 0 && scrapeResultOk(dl) ) {
        if (bDebugLog) sExplainFP += "Not FP: 0 peers\n";
        return false;
      }
      
      int shareRatio = dl.getStats().getShareRatio();
      boolean bLastMatched = (shareRatio != -1) && (shareRatio < minQueueingShareRatio);
      
      if (bDebugLog) sExplainFP += "  shareRatio("+shareRatio+") < "+minQueueingShareRatio+"="+bLastMatched+"\n";
      if (!bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ALL) {
        if (bDebugLog) sExplainFP += "..Not FP.  Exit Early\n";
        return false;
      }
      if (bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ANY) {
        if (bDebugLog) sExplainFP += "..Is FP.  Exit Early\n";
        return true;
      }
      
      bLastMatched = (iFirstPrioritySeedingMinutes == 0);
      if (!bLastMatched) {
        long timeSeeding = dl.getStats().getSecondsOnlySeeding();
        if (timeSeeding > 0) {
          bLastMatched = (timeSeeding < (iFirstPrioritySeedingMinutes * 60));
          if (bDebugLog) sExplainFP += "  SeedingTime("+timeSeeding+") < "+(iFirstPrioritySeedingMinutes*60)+"="+bLastMatched+"\n";
          if (!bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ALL) {
            if (bDebugLog) sExplainFP += "..Not FP.  Exit Early\n";
            return false;
          }
          if (bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ANY) {
            if (bDebugLog) sExplainFP += "..Is FP.  Exit Early\n";
            return true;
          }
        }
      } else if (bDebugLog) {
        sExplainFP += "  SeedingTime setting == 0:  Ignored";
      }

      bLastMatched = (iFirstPriorityDLMinutes == 0);
      if (!bLastMatched) {
        long timeDLing = dl.getStats().getSecondsDownloading();
        if (timeDLing > 0) {
          bLastMatched = (timeDLing < (iFirstPriorityDLMinutes * 60));
          if (bDebugLog) sExplainFP += "  DLTime("+timeDLing+") < "+(iFirstPriorityDLMinutes*60)+"="+bLastMatched+"\n";
          if (!bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ALL) {
            if (bDebugLog) sExplainFP += "..Not FP.  Exit Early\n";
            return false;
          }
          if (bLastMatched && iFirstPriorityType == FIRSTPRIORITY_ANY) {
            if (bDebugLog) sExplainFP += "..Is FP.  Exit Early\n";
            ret