/*
* Created on Dec 4, 2009
* Created by Paul Gardner
*
* Copyright 2009 Vuze, Inc. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License only.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*/
package org.gudy.azureus2.core3.tracker.client.impl;
import java.net.URL;
import java.util.*;
import org.gudy.azureus2.core3.logging.LogEvent;
import org.gudy.azureus2.core3.logging.Logger;
import org.gudy.azureus2.core3.peer.PEPeerSource;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.torrent.TOTorrentAnnounceURLSet;
import org.gudy.azureus2.core3.torrent.TOTorrentException;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncer;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncerDataProvider;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncerException;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncerResponse;
import org.gudy.azureus2.core3.tracker.client.impl.bt.TRTrackerBTAnnouncerImpl;
import org.gudy.azureus2.core3.tracker.client.impl.dht.TRTrackerDHTAnnouncerImpl;
import org.gudy.azureus2.core3.util.AEThread2;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.IndentWriter;
import org.gudy.azureus2.core3.util.SimpleTimer;
import org.gudy.azureus2.core3.util.SystemTime;
import org.gudy.azureus2.core3.util.TimerEvent;
import org.gudy.azureus2.core3.util.TimerEventPerformer;
import org.gudy.azureus2.core3.util.TorrentUtils;
import org.gudy.azureus2.plugins.download.DownloadAnnounceResult;
import com.aelitis.azureus.core.tracker.TrackerPeerSource;
import com.aelitis.azureus.core.util.CopyOnWriteList;
public class
TRTrackerAnnouncerMuxer
extends TRTrackerAnnouncerImpl
{
private static final int ACT_CHECK_INIT_DELAY = 2500;
private static final int ACT_CHECK_INTERIM_DELAY = 10*1000;
private static final int ACT_CHECK_IDLE_DELAY = 30*1000;
private static final int ACT_CHECK_SEEDING_SHORT_DELAY = 60*1000;
private static final int ACT_CHECK_SEEDING_LONG_DELAY = 3*60*1000;
private String[] networks;
private boolean is_manual;
private long create_time = SystemTime.getMonotonousTime();
private CopyOnWriteList<TRTrackerAnnouncerHelper> announcers = new CopyOnWriteList<TRTrackerAnnouncerHelper>();
private Set<TRTrackerAnnouncerHelper> activated = new HashSet<TRTrackerAnnouncerHelper>();
private long last_activation_time;
private Set<String> failed_urls = new HashSet<String>();
private volatile TimerEvent event;
private TRTrackerAnnouncerDataProvider provider;
private String ip_override;
private boolean complete;
private boolean stopped;
private boolean destroyed;
private TRTrackerAnnouncerHelper last_best_active;
private long last_best_active_set_time;
private Map<String,StatusSummary> recent_responses = new HashMap<String,StatusSummary>();
private TRTrackerAnnouncerResponse last_response_informed;
protected
TRTrackerAnnouncerMuxer(
TOTorrent _torrent,
String[] _networks,
boolean _manual )
throws TRTrackerAnnouncerException
{
super( _torrent );
try{
last_response_informed = new TRTrackerAnnouncerResponseImpl( null, _torrent.getHashWrapper(), TRTrackerAnnouncerResponse.ST_OFFLINE, TRTrackerAnnouncer.REFRESH_MINIMUM_SECS, "Initialising" );
}catch( TOTorrentException e ){
Logger.log(new LogEvent( _torrent, LOGID, "Torrent hash retrieval fails", e));
throw( new TRTrackerAnnouncerException( "TRTrackerAnnouncer: URL encode fails"));
}
networks = _networks;
is_manual = _manual;
split();
}
protected void
split()
throws TRTrackerAnnouncerException
{
TRTrackerAnnouncerHelper to_activate = null;
synchronized( this ){
if ( stopped || destroyed ){
return;
}
TOTorrent torrent = getTorrent();
TOTorrentAnnounceURLSet[] sets = torrent.getAnnounceURLGroup().getAnnounceURLSets();
// sanitise dht entries
if ( sets.length == 0 ){
sets = new TOTorrentAnnounceURLSet[]{ torrent.getAnnounceURLGroup().createAnnounceURLSet( new URL[]{ torrent.getAnnounceURL()})};
}else{
boolean found_decentralised = false;
boolean modified = false;
for ( int i=0;i<sets.length;i++ ){
TOTorrentAnnounceURLSet set = sets[i];
URL[] urls = set.getAnnounceURLs().clone();
for (int j=0;j<urls.length;j++){
URL u = urls[j];
if ( u != null && TorrentUtils.isDecentralised( u )){
if ( found_decentralised ){
modified = true;
urls[j] = null;
}else{
found_decentralised = true;
}
}
}
}
if ( modified ){
List<TOTorrentAnnounceURLSet> s_list = new ArrayList<TOTorrentAnnounceURLSet>();
for ( TOTorrentAnnounceURLSet set: sets ){
URL[] urls = set.getAnnounceURLs();
List<URL> u_list = new ArrayList<URL>( urls.length );
for ( URL u: urls ){
if ( u != null ){
u_list.add( u );
}
}
if ( u_list.size() > 0 ){
s_list.add( torrent.getAnnounceURLGroup().createAnnounceURLSet( u_list.toArray( new URL[ u_list.size() ])));
}
}
sets = s_list.toArray( new TOTorrentAnnounceURLSet[ s_list.size() ]);
}
}
List<TOTorrentAnnounceURLSet[]> new_sets = new ArrayList<TOTorrentAnnounceURLSet[]>();
if ( is_manual || sets.length < 2 ){
new_sets.add( sets );
}else{
List<TOTorrentAnnounceURLSet> list = new ArrayList<TOTorrentAnnounceURLSet>( Arrays.asList( sets ));
// often we have http:/xxxx/ and udp:/xxxx/ as separate groups - keep these together
while( list.size() > 0 ){
TOTorrentAnnounceURLSet set1 = list.remove(0);
boolean done = false;
URL[] urls1 = set1.getAnnounceURLs();
if ( urls1.length == 1 ){
URL url1 = urls1[0];
String prot1 = url1.getProtocol().toLowerCase();
String host1 = url1.getHost();
for (int i=0;i<list.size();i++){
TOTorrentAnnounceURLSet set2 = list.get(i);
URL[] urls2 = set2.getAnnounceURLs();
if ( urls2.length == 1 ){
URL url2 = urls2[0];
String prot2 = url2.getProtocol().toLowerCase();
String host2 = url2.getHost();
if ( host1.equals( host2 )){
if ( ( prot1.equals( "udp" ) && prot2.startsWith( "http" )) ||
( prot2.equals( "udp" ) && prot1.startsWith( "http" ))){
list.remove( i );
new_sets.add( new TOTorrentAnnounceURLSet[]{ set1, set2 });
done = true;
}
}
}
}
}
if ( !done ){
new_sets.add( new TOTorrentAnnounceURLSet[]{ set1 });
}
}
}
// work out the difference
Iterator<TOTorrentAnnounceURLSet[]> ns_it = new_sets.iterator();
List<TRTrackerAnnouncerHelper> existing_announcers = announcers.getList();
List<TRTrackerAnnouncerHelper> new_announcers = new ArrayList<TRTrackerAnnouncerHelper>();
// first look for unchanged sets
while( ns_it.hasNext()){
TOTorrentAnnounceURLSet[] ns = ns_it.next();
Iterator<TRTrackerAnnouncerHelper> a_it = existing_announcers.iterator();
while( a_it.hasNext()){
TRTrackerAnnouncerHelper a = a_it.next();
TOTorrentAnnounceURLSet[] os = a.getAnnounceSets();
if ( same( ns, os )){
ns_it.remove();
a_it.remove();
new_announcers.add( a );
break;
}
}
}
// reuse existing announcers
// first remove dht ones from the equation
TRTrackerAnnouncerHelper existing_dht_announcer = null;
TOTorrentAnnounceURLSet[] new_dht_set = null;
ns_it = new_sets.iterator();
while( ns_it.hasNext()){
TOTorrentAnnounceURLSet[] x = ns_it.next();
if ( TorrentUtils.isDecentralised( x[0].getAnnounceURLs()[0])){
new_dht_set = x;
ns_it.remove();
break;
}
}
Iterator<TRTrackerAnnouncerHelper> an_it = existing_announcers.iterator();
while( an_it.hasNext()){
TRTrackerAnnouncerHelper a = an_it.next();
TOTorrentAnnounceURLSet[] x = a.getAnnounceSets();
if ( TorrentUtils.isDecentralised( x[0].getAnnounceURLs()[0])){
existing_dht_announcer = a;
an_it.remove();
break;
}
}
if ( existing_dht_announcer != null && new_dht_set != null ){
new_announcers.add( existing_dht_announcer );
}else if ( existing_dht_announcer != null ){
activated.remove( existing_dht_announcer );
existing_dht_announcer.destroy();
}else if ( new_dht_set != null ){
TRTrackerAnnouncerHelper a = create( torrent, new_dht_set );
new_announcers.add( a );
}
// now do the non-dht ones
ns_it = new_sets.iterator();
while( ns_it.hasNext() && existing_announcers.size() > 0 ){
TRTrackerAnnouncerHelper a = existing_announcers.remove(0);
TOTorrentAnnounceURLSet[] s = ns_it.next();
ns_it.remove();
if ( activated.contains( a ) &&
torrent.getPrivate() &&
a instanceof TRTrackerBTAnnouncerImpl ){
URL url = a.getTrackerURL();
if ( url != null ){
forceStop((TRTrackerBTAnnouncerImpl)a, url );
}
}
a.setAnnounceSets( s );
new_announcers.add( a );
}
// create any new ones required
ns_it = new_sets.iterator();
while( ns_it.hasNext()){
TOTorrentAnnounceURLSet[] s = ns_it.next();
TRTrackerAnnouncerHelper a = create( torrent, s );
new_announcers.add( a );
}
// finally fix up the announcer list to represent the new state
Iterator<TRTrackerAnnouncerHelper> a_it = announcers.iterator();
while( a_it.hasNext()){
TRTrackerAnnouncerHelper a = a_it.next();
if ( !new_announcers.contains( a )){
a_it.remove();
try{
if ( activated.contains( a ) &&
torrent.getPrivate() &&
a instanceof TRTrackerBTAnnouncerImpl ){
URL url = a.getTrackerURL();
if ( url != null ){
forceStop((TRTrackerBTAnnouncerImpl)a, url );
}
}
}finally{
if (Logger.isEnabled()) {
Logger.log(new LogEvent(getTorrent(), LOGID, "Deactivating " + getString( a.getAnnounceSets())));
}
activated.remove( a );
a.destroy();
}
}
}
a_it = new_announcers.iterator();
while( a_it.hasNext()){
TRTrackerAnnouncerHelper a = a_it.next();
if ( !announcers.contains( a )){
announcers.add( a );
}
}
if ( !is_manual && announcers.size() > 0 ){
if ( activated.size() == 0 ){
TRTrackerAnnouncerHelper a = announcers.get(0);
if (Logger.isEnabled()) {
Logger.log(new LogEvent(getTorrent(), LOGID, "Activating " + getString( a.getAnnounceSets())));
}
activated.add( a );
last_activation_time = SystemTime.getMonotonousTime();
if ( provider != null ){
to_activate = a;
}
}
setupActivationCheck( ACT_CHECK_INIT_DELAY );
}
}
if ( to_activate != null ){
if ( complete ){
to_activate.complete( true );
}else{
to_activate.update( false );
}
}
}
protected void
setupActivationCheck(
int delay )
{
if ( announcers.size() > activated.size()){
event = SimpleTimer.addEvent(
"TRMuxer:check",
SystemTime.getOffsetTime( delay ),
new TimerEventPerformer()
{
public void
perform(
TimerEvent event )
{
checkActivation( false );
}
});
}
}
protected void
checkActivation(
boolean force )
{
synchronized( this ){
int next_check_delay;
if ( destroyed ||
stopped ||
announcers.size() <= activated.size()){
return;
}
if ( provider == null ){
next_check_delay = ACT_CHECK_INIT_DELAY;
}else{
boolean activate = force;
boolean seeding = provider.getRemaining() == 0;
if ( seeding && activated.size() > 0 ){
// when seeding we only activate on tracker fail or major lack of connections
// as normally we rely on downloaders rotating and finding us
int connected = provider.getConnectedConnectionCount();
if ( connected < 1 ){
activate = SystemTime.getMonotonousTime() - last_activation_time >= 60*1000;
next_check_delay = ACT_CHECK_SEEDING_SHORT_DELAY;
}else if ( connected < 3 ){
next_check_delay = ACT_CHECK_SEEDING_LONG_DELAY;
}else{
next_check_delay = 0;
}
}else{
int allowed = provider.getMaxNewConnectionsAllowed();
int pending = provider.getPendingConnectionCount();
int connected = provider.getConnectedConnectionCount();
int online = 0;
for ( TRTrackerAnnouncerHelper a: activated ){
TRTrackerAnnouncerResponse response = a.getLastResponse();
if ( response != null &&
response.getStatus() == TRTrackerAnnouncerResponse.ST_ONLINE ){
online++;
}
}
/*
System.out.println(
"checkActivation: announcers=" + announcers.size() +
", active=" + activated.size() +
", online=" + online +
", allowed=" + allowed +
", pending=" + pending +
", connected=" + connected +
", seeding=" + seeding );
*/
if ( online == 0 ){
activate = true;
// no trackers online, start next and recheck soon
next_check_delay = ACT_CHECK_INIT_DELAY;
}else{
int potential = connected + pending;
if ( potential < 10 ){
// minimal connectivity
activate = true;
next_check_delay = ACT_CHECK_INIT_DELAY;
}else if ( allowed >= 5 && pending < 3*allowed/4 ){
// not enough to fulfill our needs
activate = true;
next_check_delay = ACT_CHECK_INTERIM_DELAY;
}else{
// things look good, recheck in a bit
next_check_delay = ACT_CHECK_IDLE_DELAY;
}
}
}
if ( activate ){
for ( TRTrackerAnnouncerHelper a: announcers ){
if ( !activated.contains( a )){
if (Logger.isEnabled()) {
Logger.log(new LogEvent(getTorrent(), LOGID, "Activating " + getString( a.getAnnounceSets())));
}
activated.add( a );
last_activation_time = SystemTime.getMonotonousTime();
if ( complete ){
a.complete( true );
}else{
a.update( false );
}
break;
}
}
}
}
if ( next_check_delay > 0 ){
setupActivationCheck( next_check_delay );
}
}
}
private String
getString(
TOTorrentAnnounceURLSet[] sets )
{
StringBuffer str = new StringBuffer();
str.append( "[" );
int num1 = 0;
for ( TOTorrentAnnounceURLSet s: sets ){
if ( num1++ > 0 ){
str.append( ", ");
}
str.append( "[" );
URL[] urls = s.getAnnounceURLs();
int num2 = 0;
for ( URL u: urls ){
if ( num2++ > 0 ){
str.append( ", ");
}
str.append( u.toExternalForm());
}
str.append( "]" );
}
str.append( "]" );
return( str.toString());
}
private boolean
same(
TOTorrentAnnounceURLSet[] s1,
TOTorrentAnnounceURLSet[] s2 )
{
boolean res = sameSupport( s1, s2 );
// System.out.println( "same->" + res + ": " + getString(s1) + "/" + getString(s2));
return( res );
}
private boolean
sameSupport(
TOTorrentAnnounceURLSet[] s1,
TOTorrentAnnounceURLSet[] s2 )
{
if ( s1.length != s2.length ){
return( false );
}
for (int i=0;i<s1.length;i++){
URL[] u1 = s1[i].getAnnounceURLs();
URL[] u2 = s2[i].getAnnounceURLs();
if ( u1.length != u2.length ){
return( false );
}
if ( u1.length == 1 ){
return( u1[0].toExternalForm().equals( u2[0].toExternalForm()));
}
Set<String> set1 = new HashSet<String>();
for ( URL u: u1 ){
set1.add( u.toExternalForm());
}
Set<String> set2 = new HashSet<String>();
for ( URL u: u2 ){
set2.add( u.toExternalForm());
}
if ( !set1.equals( set2 )){
return( false );
}
}
return( true );
}
protected void
forceStop(
final TRTrackerBTAnnouncerImpl announcer,
final URL url )
{
if (Logger.isEnabled()) {
Logger.log(new LogEvent(getTorrent(), LOGID, "Force stopping " + url + " as private torrent" ));
}
new AEThread2( "TRMux:fs", true )
{
public void
run()
{
try{
TRTrackerBTAnnouncerImpl an =
new TRTrackerBTAnnouncerImpl( getTorrent(), new TOTorrentAnnounceURLSet[0], networks, true, getHelper());
an.cloneFrom( announcer );
an.setTrackerURL( url );
an.stop( false );
an.destroy();
}catch( Throwable e ){
}
}
}.start();
}
protected TRTrackerAnnouncerHelper
create(
TOTorrent torrent,
TOTorrentAnnounceURLSet[] sets )
throws TRTrackerAnnouncerException
{
TRTrackerAnnouncerHelper announcer;
boolean decentralised;
if ( sets.length == 0 ){
decentralised = TorrentUtils.isDecentralised( torrent.getAnnounceURL());
}else{
decentralised = TorrentUtils.isDecentralised( sets[0].getAnnounceURLs()[0]);
}
if ( decentralised ){
announcer = new TRTrackerDHTAnnouncerImpl( torrent, networks, is_manual, getHelper());
}else{
announcer = new TRTrackerBTAnnouncerImpl( torrent, sets, networks, is_manual, getHelper());
}
for ( TOTorrentAnnounceURLSet set: sets ){
URL[] urls = set.getAnnounceURLs();
for ( URL u: urls ){
String key = u.toExternalForm();
StatusSummary summary = recent_responses.get( key );
if ( summary == null ){
summary = new StatusSummary( announcer, u );
recent_responses.put( key, summary );
}else{
summary.setHelper( announcer );
}
}
}
if ( provider != null ){
announcer.setAnnounceDataProvider( provider );
}
if ( ip_override != null ){
announcer.setIPOverride( ip_override );
}
return( announcer );
}
public TRTrackerAnnouncerResponse
getLastResponse()
{
TRTrackerAnnouncerResponse result = null;
TRTrackerAnnouncerHelper best = getBestActive();
if ( best != null ){
result = best.getLastResponse();
}
if ( result == null ){
result = last_response_informed;
}
return( result );
}
@Override
protected void
informResponse(
TRTrackerAnnouncerHelper helper,
TRTrackerAnnouncerResponse response )
{
URL url = response.getURL();
// can be null for external plugins (e.g. mldht...)
if ( url != null ){
synchronized( this ){
String key = url.toExternalForm();
StatusSummary summary = recent_responses.get( key );
if ( summary != null ){
summary.updateFrom( response );
}
}
}
last_response_informed = response;
// force recalc of best active next time
last_best_active_set_time = 0;
super.informResponse( helper, response );
if ( response.getStatus() != TRTrackerAnnouncerResponse.ST_ONLINE ){
URL u = response.getURL();
if ( u != null ){
String s = u.toExternalForm();
synchronized( failed_urls ){
if ( failed_urls.contains( s )){
return;
}
failed_urls.add( s );
}
}
checkActivation( true );
}
}
public boolean
isManual()
{
return( is_manual );
}
public void
setAnnounceDataProvider(
TRTrackerAnnouncerDataProvider _provider )
{
List<TRTrackerAnnouncerHelper> to_set;
synchronized( this ){
provider = _provider;
to_set = announcers.getList();
}
for ( TRTrackerAnnouncer announcer: to_set ){
announcer.setAnnounceDataProvider( provider );
}
}
protected TRTrackerAnnouncerHelper
getBestActive()
{
long now = SystemTime.getMonotonousTime();
if ( now - last_best_active_set_time < 1000 ){
return( last_best_active );
}
last_best_active = getBestActiveSupport();
last_best_active_set_time = now;
return( last_best_active );
}
protected TRTrackerAnnouncerHelper
getBestActiveSupport()
{
List<TRTrackerAnnouncerHelper> x = announcers.getList();
TRTrackerAnnouncerHelper error_resp = null;
for ( TRTrackerAnnouncerHelper announcer: x ){
TRTrackerAnnouncerResponse response = announcer.getLastResponse();
if ( response != null ){
int resp_status = response.getStatus();
if ( resp_status == TRTrackerAnnouncerResponse.ST_ONLINE ){
return( announcer );
}else if ( error_resp == null && resp_status == TRTrackerAnnouncerResponse.ST_REPORTED_ERROR ){
error_resp = announcer;
}
}
}
if ( error_resp != null ){
return( error_resp );
}
if ( x.size() > 0 ){
return( x.get(0));
}
return( null );
}
public URL
getTrackerURL()
{
TRTrackerAnnouncerHelper active = getBestActive();
if ( active != null ){
return( active.getTrackerURL());
}
return( null );
}
public void
setTrackerURL(
URL url )
{
List<List<String>> groups = new ArrayList<List<String>>();
List<String> group = new ArrayList<String>();
group.add( url.toExternalForm());
groups.add( group );
TorrentUtils.listToAnnounceGroups( groups, getTorrent());
resetTrackerUrl( false );
}
public void
resetTrackerUrl(
boolean shuffle )
{
try{
split();
}catch( Throwable e ){
Debug.out( e );
}
for ( TRTrackerAnnouncer announcer: announcers ){
announcer.resetTrackerUrl( shuffle );
}
}
public void
setIPOverride(
String override )
{
List<TRTrackerAnnouncerHelper> to_set;
synchronized( this ){
to_set = announcers.getList();
ip_override = override;
}
for ( TRTrackerAnnouncer announcer: to_set ){
announcer.setIPOverride( override );
}
}
public void
clearIPOverride()
{
List<TRTrackerAnnouncerHelper> to_clear;
synchronized( this ){
to_clear = announcers.getList();
ip_override = null;
}
for ( TRTrackerAnnouncer announcer: to_clear ){
announcer.clearIPOverride();
}
}
public void
setRefreshDelayOverrides(
int percentage )
{
for ( TRTrackerAnnouncer announcer: announcers ){
announcer.setRefreshDelayOverrides( percentage );
}
}
public int
getTimeUntilNextUpdate()
{
TRTrackerAnnouncerHelper active = getBestActive();
if ( active != null ){
return( active.getTimeUntilNextUpdate());
}
return( Integer.MAX_VALUE );
}
public int
getLastUpdateTime()
{
TRTrackerAnnouncerHelper active = getBestActive();
if ( active != null ){
return( active.getLastUpdateTime());
}
return( 0 );
}
public void
update(
boolean force )
{
List<TRTrackerAnnouncerHelper> to_update;
synchronized( this ){
to_update = is_manual?announcers.getList():new ArrayList<TRTrackerAnnouncerHelper>( activated );
}
for ( TRTrackerAnnouncer announcer: to_update ){
announcer.update(force);
}
}
public void
complete(
boolean already_reported )
{
List<TRTrackerAnnouncerHelper> to_complete;
synchronized( this ){
complete = true;
to_complete = is_manual?announcers.getList():new ArrayList<TRTrackerAnnouncerHelper>( activated );
}
for ( TRTrackerAnnouncer announcer: to_complete ){
announcer.complete( already_reported );
}
}
public void
stop(
boolean for_queue )
{
List<TRTrackerAnnouncerHelper> to_stop;
synchronized( this ){
stopped = true;
to_stop = is_manual?announcers.getList():new ArrayList<TRTrackerAnnouncerHelper>( activated );
activated.clear();
}
for ( TRTrackerAnnouncer announcer: to_stop ){
announcer.stop( for_queue );
}
}
public void
destroy()
{
TRTrackerAnnouncerFactoryImpl.destroy( this );
List<TRTrackerAnnouncerHelper> to_destroy;
synchronized( this ){
destroyed = true;
to_destroy = announcers.getList();
}
for ( TRTrackerAnnouncer announcer: to_destroy ){
announcer.destroy();
}
TimerEvent ev = event;
if ( ev != null ){
ev.cancel();
}
}
public int
getStatus()
{
TRTrackerAnnouncer max_announcer = getBestAnnouncer();
return( max_announcer==null?-1:max_announcer.getStatus());
}
public String
getStatusString()
{
TRTrackerAnnouncer max_announcer = getBestAnnouncer();
return( max_announcer==null?"":max_announcer.getStatusString());
}
public TRTrackerAnnouncer
getBestAnnouncer()
{
int max = -1;
TRTrackerAnnouncer max_announcer = null;
for ( TRTrackerAnnouncer announcer: announcers ){
int status = announcer.getStatus();
if ( status > max ){
max_announcer = announcer;
max = status;
}
}
return( max_announcer==null?this:max_announcer );
}
public void
refreshListeners()
{
informURLRefresh();
}
public void
setAnnounceResult(
DownloadAnnounceResult result )
{
// this is only used for setting DHT results
for ( TRTrackerAnnouncer announcer: announcers ){
if ( announcer instanceof TRTrackerDHTAnnouncerImpl ){
announcer.setAnnounceResult( result );
return;
}
}
// TODO: we should always create a DHT entry and have it denote DHT tracking for all circustances
// have the DHT plugin set it to offline if disabled
List<TRTrackerAnnouncerHelper> x = announcers.getList();
if ( x.size() > 0 ){
x.get(0).setAnnounceResult( result );
}
}
protected int
getPeerCacheLimit()
{
synchronized( this ){
if ( activated.size() < announcers.size()){
return( 0 );
}
}
if ( SystemTime.getMonotonousTime() - create_time < 15*1000 ){
return( 0 );
}
TRTrackerAnnouncer active = getBestActive();
if ( active != null && provider != null && active.getStatus() == TRTrackerAnnouncerResponse.ST_ONLINE ){
if ( provider.getMaxNewConnectionsAllowed() > 0 &&
provider.getPendingConnectionCount() == 0 ){
return( 5 );
}else{
return( 0 );
}
}
return( 10 );
}
public TrackerPeerSource
getTrackerPeerSource(
final TOTorrentAnnounceURLSet set )
{
URL[] urls = set.getAnnounceURLs();
final String[] url_strs = new String[ urls.length ];
for ( int i=0;i<urls.length;i++ ){
url_strs[i] = urls[i].toExternalForm();
}
return(
new TrackerPeerSource()
{
private StatusSummary _summary;
private boolean enabled;
private long fixup_time;
private StatusSummary
fixup()
{
long now = SystemTime.getMonotonousTime();
if ( now - fixup_time > 1000 ){
long most_recent = 0;
StatusSummary summary = null;
synchronized( TRTrackerAnnouncerMuxer.this ){
for ( String str: url_strs ){
StatusSummary s = recent_responses.get( str );
if ( s != null ){
if ( summary == null || s.getTime() > most_recent ){
summary = s;
most_recent = s.getTime();
}
}
}
}
if ( provider != null ){
enabled = provider.isPeerSourceEnabled( PEPeerSource.PS_BT_TRACKER );
}
if ( summary != null ){
_summary = summary;
}
fixup_time = now;
}
return( _summary );
}
public int
getType()
{
return( TrackerPeerSource.TP_TRACKER );
}
public String
getName()
{
StatusSummary summary = fixup();
if ( summary != null ){
String str =summary.getURL().toExternalForm();
int pos = str.indexOf( '?' );
if ( pos != -1 ){
str = str.substring( 0, pos );
}
return( str );
}
return( url_strs[0] );
}
public int
getStatus()
{
StatusSummary summary = fixup();
if ( !enabled ){
return( ST_DISABLED );
}
if ( summary != null ){
return( summary.getStatus());
}
return( ST_QUEUED );
}
public String
getStatusString()
{
StatusSummary summary = fixup();
if ( summary != null && enabled ){
return( summary.getStatusString());
}
return( null );
}
public int
getSeedCount()
{
StatusSummary summary = fixup();
if ( summary != null ){
return( summary.getSeedCount());
}
return( -1 );
}
public int
getLeecherCount()
{
StatusSummary summary = fixup();
if ( summary != null ){
return( summary.getLeecherCount());
}
return( -1 );
}
public int
getPeers()
{
StatusSummary summary = fixup();
if ( summary != null ){
return( summary.getPeers());
}
return( -1 );
}
public int
getSecondsToUpdate()
{
StatusSummary summary = fixup();
if ( summary != null ){
return( summary.getSecondsToUpdate());
}
return( -1 );
}
public int
getInterval()
{
StatusSummary summary = fixup();
if ( summary != null ){
return( summary.getInterval());
}
return( -1 );
}
public int
getMinInterval()
{
StatusSummary summary = fixup();
if ( summary != null && enabled ){
return( summary.getMinInterval());
}
return( -1 );
}
public boolean
isUpdating()
{
StatusSummary summary = fixup();
if ( summary != null && enabled ){
return( summary.isUpdating());
}
return( false );
}
public boolean
canManuallyUpdate()
{
StatusSummary summary = fixup();
if ( summary == null ){
return( false );
}
return( summary.canManuallyUpdate());
}
public void
manualUpdate()
{
StatusSummary summary = fixup();
if ( summary != null ){
summary.manualUpdate();
}
}
});
}
public void
generateEvidence(
IndentWriter writer )
{
for ( TRTrackerAnnouncer announcer: announcers ){
announcer.generateEvidence(writer);
}
}
private static class
StatusSummary
{
private TRTrackerAnnouncerHelper helper;
private long time;
private URL url;
private int status;
private String status_str;
private int seeds = -1;
private int leechers = -1;
private int peers = -1;
private int interval;
private int min_interval;
protected
StatusSummary(
TRTrackerAnnouncerHelper _helper,
URL _url )
{
helper = _helper;
url = _url;
status = TrackerPeerSource.ST_QUEUED;
}
protected void
setHelper(
TRTrackerAnnouncerHelper _helper )
{
helper = _helper;
}
protected void
updateFrom(
TRTrackerAnnouncerResponse response )
{
time = SystemTime.getMonotonousTime();
int state = response.getStatus();
if ( state == TRTrackerAnnouncerResponse.ST_ONLINE ){
status = TrackerPeerSource.ST_ONLINE;
seeds = response.getScrapeCompleteCount();
leechers = response.getScrapeIncompleteCount();
peers = response.getPeers().length;
}else{
status = TrackerPeerSource.ST_ERROR;
status_str = response.getStatusString();
}
interval = (int)helper.getInterval();
min_interval = (int)helper.getMinInterval();
}
public long
getTime()
{
return( time );
}
public URL
getURL()
{
return( url );
}
public int
getStatus()
{
return( status );
}
public String
getStatusString()
{
return( status_str );
}
public int
getSeedCount()
{
return( seeds );
}
public int
getLeecherCount()
{
return( leechers );
}
public int
getPeers()
{
return( peers );
}
public boolean
isUpdating()
{
return( helper.isUpdating());
}
public int
getInterval()
{
return( interval );
}
public int
getMinInterval()
{
return( min_interval );
}
public int
getSecondsToUpdate()
{
return( helper.getTimeUntilNextUpdate());
}
public boolean
canManuallyUpdate()
{
return( ((SystemTime.getCurrentTime() / 1000 - helper.getLastUpdateTime() >= TRTrackerAnnouncer.REFRESH_MINIMUM_SECS)));
}
public void
manualUpdate()
{
helper.update( true );
}
}
}