/**
* Created on Apr 17, 2007
* Created by Alan Snyder
* Copyright (C) 2007 Aelitis, 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; either version 2
* of the License, or (at your option) any later version.
* 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.
*
* AELITIS, SAS au capital de 63.529,40 euros
* 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
*
*/
package com.aelitis.azureus.core.networkmanager.admin.impl;
import com.aelitis.azureus.core.networkmanager.NetworkManager;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdminSpeedTestScheduler;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdminSpeedTester;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdminSpeedTesterResult;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.core3.disk.DiskManager;
import org.gudy.azureus2.core3.disk.DiskManagerPiece;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.download.DownloadManagerPeerListener;
import org.gudy.azureus2.core3.download.DownloadManagerState;
import org.gudy.azureus2.core3.peer.PEPeer;
import org.gudy.azureus2.core3.peer.PEPeerManager;
import org.gudy.azureus2.core3.peer.PEPiece;
import org.gudy.azureus2.core3.security.SECertificateListener;
import org.gudy.azureus2.core3.security.SESecurityManager;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.plugins.PluginInterface;
import org.gudy.azureus2.plugins.download.Download;
import org.gudy.azureus2.plugins.download.DownloadStats;
import org.gudy.azureus2.plugins.download.DownloadRemovalVetoException;
import org.gudy.azureus2.plugins.download.DownloadException;
import org.gudy.azureus2.plugins.peers.Peer;
import org.gudy.azureus2.plugins.peers.PeerManager;
import org.gudy.azureus2.plugins.torrent.Torrent;
import org.gudy.azureus2.plugins.torrent.TorrentAttribute;
import org.gudy.azureus2.pluginsimpl.local.PluginCoreUtils;
import org.gudy.azureus2.pluginsimpl.local.torrent.TorrentImpl;
import java.security.cert.X509Certificate;
import java.util.*;
import java.io.File;
import java.net.URL;
import java.text.SimpleDateFormat;
public class NetworkAdminSpeedTesterBTImpl
extends NetworkAdminSpeedTesterImpl
implements NetworkAdminSpeedTester
{
public static final String DOWNLOAD_AVE = "download-ave";
public static final String UPLOAD_AVE = "upload-ave";
public static final String DOWNLOAD_STD_DEV = "download-std-dev";
public static final String UPLOAD_STD_DEV = "upload-std-dev";
private static int testMode = TEST_TYPE_UPLOAD_ONLY;
private static TorrentAttribute speedTestAttrib;
private static NetworkAdminSpeedTesterResult lastResult;
protected static void
startUp(
PluginInterface plugin )
{
speedTestAttrib = plugin.getTorrentManager().getPluginAttribute(NetworkAdminSpeedTesterBTImpl.class.getName()+".test.attrib");
org.gudy.azureus2.plugins.download.DownloadManager dm = plugin.getDownloadManager();
Download[] downloads = dm.getDownloads();
if(downloads!=null){
int num = downloads.length;
for(int i=0; i<num; i++){
Download download = downloads[i];
if( download.getBooleanAttribute(speedTestAttrib) ){
try{
if (download.getState() != Download.ST_STOPPED ){
try{
download.stop();
}catch( Throwable e ){
Debug.out(e);
}
}
download.remove(true,true);
}catch(Throwable e ){
Debug.out("Had "+e.getMessage()+" while trying to remove "+downloads[i].getName());
}
}
}
}
}
protected static NetworkAdminSpeedTesterResult
getLastResult()
{
return( lastResult );
}
private PluginInterface plugin;
private boolean test_started;
private boolean test_completed;
private boolean use_crypto;
private volatile boolean aborted;
private String deferred_abort;
/**
*
* @param pi - PluginInterface is used to get Manager classes.
*/
public NetworkAdminSpeedTesterBTImpl(PluginInterface pi){
plugin = pi;
}
public int
getTestType()
{
return( NetworkAdminSpeedTestScheduler.TEST_TYPE_BT );
}
public void setMode(int mode) {
testMode = mode;
}
public int
getMode()
{
return( testMode );
}
public void
setUseCrypto(
boolean _use_crypto )
{
use_crypto = _use_crypto;
}
public boolean
getUseCrypto()
{
return( use_crypto );
}
/**
* The downloads have been stopped just need to do the testing.
* @param tot - Torrent recieved from testing service.
*/
public synchronized void
start(
TOTorrent tot )
{
if ( test_started ){
Debug.out( "Test already started!" );
return;
}
test_started = true;
//OK lets start the test.
try{
TorrentUtils.setFlag( tot, TorrentUtils.TORRENT_FLAG_LOW_NOISE, true );
Torrent torrent = new TorrentImpl(tot);
String fileName = torrent.getName();
sendStageUpdateToListeners(MessageText.getString("SpeedTestWizard.stage.message.preparing"));
//create a blank file of specified size. (using the temporary name.)
File saveLocation = AETemporaryFileHandler.createTempFile();
File baseDir = saveLocation.getParentFile();
File blankFile = new File(baseDir,fileName);
File blankTorrentFile = new File( baseDir, "speedTestTorrent.torrent" );
torrent.writeToFile(blankTorrentFile);
URL announce_url = torrent.getAnnounceURL();
if ( announce_url.getProtocol().equalsIgnoreCase( "https" )){
SESecurityManager.setCertificateHandler(
announce_url,
new SECertificateListener()
{
public boolean
trustCertificate(
String resource,
X509Certificate cert )
{
return( true );
}
});
}
Download speed_download = plugin.getDownloadManager().addDownloadStopped( torrent, blankTorrentFile ,blankFile);
speed_download.setBooleanAttribute(speedTestAttrib,true);
DownloadManager core_download = PluginCoreUtils.unwrap( speed_download );
core_download.setPieceCheckingEnabled( false );
// make sure we've got a bunch of upload slots
core_download.getDownloadState().setIntParameter( DownloadManagerState.PARAM_MAX_UPLOADS, 32 );
core_download.getDownloadState().setIntParameter( DownloadManagerState.PARAM_MAX_UPLOADS_WHEN_SEEDING, 32 );
if ( use_crypto ){
core_download.setCryptoLevel( NetworkManager.CRYPTO_OVERRIDE_REQUIRED );
}
core_download.addPeerListener(
new DownloadManagerPeerListener()
{
public void
peerManagerWillBeAdded(
PEPeerManager peer_manager )
{
DiskManager disk_manager = peer_manager.getDiskManager();
DiskManagerPiece[] pieces = disk_manager.getPieces();
int startPiece = setStartPieceBasedOnMode(testMode,pieces.length);
for ( int i=startPiece; i<pieces.length; i++ ){
pieces[i].setDone( true );
}
}
public void
peerManagerAdded( PEPeerManager peer_manager )
{
}
public void
peerManagerRemoved(PEPeerManager manager )
{
}
public void
peerAdded(PEPeer peer )
{
}
public void
peerRemoved(PEPeer peer )
{
}
public void
pieceAdded(PEPiece piece )
{
}
public void
pieceRemoved(PEPiece piece )
{
}
});
speed_download.moveTo( 1 );
speed_download.setFlag( Download.FLAG_DISABLE_AUTO_FILE_MOVE, true );
core_download.initialize();
core_download.setForceStart( true );
TorrentSpeedTestMonitorThread monitor = new TorrentSpeedTestMonitorThread( speed_download );
monitor.start();
//The test has now started!!
}catch( Throwable e){
test_completed = true;
abort( "Could not start test", e );
}
}
public void
complete(
NetworkAdminSpeedTesterResult result )
{
sendResultToListeners( result );
}
protected void
abort(
String reason,
Throwable cause )
{
String msg;
if ( cause instanceof RuntimeException ){
msg = Debug.getNestedExceptionMessageAndStack( cause );
}else{
msg = Debug.getNestedExceptionMessage( cause );
}
abort( reason + ": " + msg );
}
public void
abort(
String reason )
{
reason = "Test aborted: " + reason;
synchronized( this ){
if ( aborted ){
return;
}
aborted = true;
// we need to defer the reporting of a failure until the test is complete
// as this prevents us from starting another test while the current one is
// terminating
if ( test_started && !test_completed ){
deferred_abort = reason;
return;
}
}
sendResultToListeners( new BitTorrentResult( reason ));
}
/**
* Get the result for
* @return Result object of speed test.
*/
public NetworkAdminSpeedTesterResult getResult(){
return lastResult;
}
// ------------------ private methods ---------------
/**
* Depending on the mode we want to upload all the set all, none or only
* half the pieces to done.
* @param mode - int that maps to NetworkAdminSpeedTestScheduler.TEST_TYPE...
* @param totalPieces - total pieces in this test torrent.
* @return - int - the starting piece number to setDone to true.
*/
private static int setStartPieceBasedOnMode(int mode, int totalPieces){
//if(mode==TEST_TYPE_UPLOAD_AND_DOWNLOAD){
// //upload half the pieces
// return totalPieces/2;
//}else
if(mode==TEST_TYPE_UPLOAD_ONLY){
//upload all the pieces
return 0;
}else if(mode==TEST_TYPE_DOWNLOAD_ONLY){
//download all the pieces
return totalPieces;
}
else
throw new IllegalStateException("Did not recognize the NetworkAdmin Speed Test type. mode="+mode);
}
/** -------------------- helper class to monitor test. ------------------- **/
private class TorrentSpeedTestMonitorThread
extends Thread
{
List historyDownloadSpeed = new LinkedList(); //<Long>
List historyUploadSpeed = new LinkedList(); //<Long>
List timestamps = new LinkedList(); //<Long>
Download testDownload;
public static final long MAX_TEST_TIME = 2*60*1000; //Limit test to 2 minutes.
public static final long MAX_PEAK_TIME = 30 * 1000; //Limit to 30 seconds at peak.
long startTime;
long peakTime;
long peakRate;
public static final String AVE = "ave";
public static final String STD_DEV = "stddev";
public TorrentSpeedTestMonitorThread( Download d )
{
testDownload = d;
}
public void run()
{
try{
Set connected_peers = new HashSet();
Set not_choked_peers = new HashSet();
Set not_choking_peers = new HashSet();
try{
startTime = SystemTime.getCurrentTime();
peakTime = startTime;
boolean testDone=false;
long lastTotalTransferredBytes=0;
sendStageUpdateToListeners(MessageText.getString("SpeedTestWizard.stage.message.starting"));
while( !( testDone || aborted )){
int state = testDownload.getState();
if ( state == Download.ST_ERROR ){
String enteredErrorState = MessageText.getString("SpeedTestWizard.abort.message.entered.error"
, new String[] {testDownload.getErrorStateDetails()} );
abort( enteredErrorState );
break;
}
if ( state == Download.ST_STOPPED ){
abort( MessageText.getString("SpeedTestWizard.abort.message.entered.queued") );
break;
}
// can flick out of force-mode when transitioning from downloading
// to seeding - easiest fix is:
if ( !testDownload.isForceStart()){
testDownload.setForceStart( true );
}
PeerManager pm = testDownload.getPeerManager();
if ( pm != null ){
Peer[] peers = pm.getPeers();
for ( int i=0;i<peers.length;i++){
Peer peer = peers[i];
// use the IP as the key so we don't count reconnects multiple times
String key = peer.getIp();
connected_peers.add( key );
if ( !peer.isChoked()){
not_choked_peers.add( key );
}
if ( !peer.isChoking()){
not_choking_peers.add( key );
}
}
}
long currTime = SystemTime.getCurrentTime();
DownloadStats stats = testDownload.getStats();
historyDownloadSpeed.add( autoboxLong(stats.getDownloaded()) );
historyUploadSpeed.add( autoboxLong(stats.getUploaded()) );
timestamps.add( autoboxLong(currTime) );
updateTestProgress(currTime,stats);
lastTotalTransferredBytes = checkForNewPeakValue( stats, lastTotalTransferredBytes, currTime );
testDone = checkForTestDone();
if(testDone)
break;
try{ Thread.sleep(1000); }
catch(InterruptedException ie){
//someone interrupted this thread for a reason. "test is now over"
abort( MessageText.getString("SpeedTestWizard.abort.message.interrupted") );
break;
}
}
//It is time to stop the test.
try{
if ( testDownload.getState() != Download.ST_STOPPED){
try{
testDownload.stop();
}catch( Throwable e ){
Debug.printStackTrace(e);
}
}
testDownload.remove(true,true);
}catch(DownloadException de){
abort( "TorrentSpeedTestMonitorThread could not stop the torrent "+testDownload.getName(), de);
}catch(DownloadRemovalVetoException drve){
abort( "TorrentSpeedTestMonitorTheard could not remove the torrent "+testDownload.getName(), drve);
}
}catch(Exception e){
abort( MessageText.getString("SpeedTestWizard.abort.message.execution.failed"),e );
}
if ( !aborted ){
// check the stats for peers we connected to during the test
String connectStats = MessageText.getString("SpeedTestWizard.stage.message.connect.stats",
new String[]{""+connected_peers.size()
,""+not_choked_peers.size()
,""+not_choking_peers.size()
});
sendStageUpdateToListeners(connectStats);
if ( connected_peers.size() == 0 ){
abort( MessageText.getString("SpeedTestWizard.abort.message.failed.peers") );
}else if ( not_choking_peers.size() == 0 && testMode!=TEST_TYPE_DOWNLOAD_ONLY ){
abort( MessageText.getString("SpeedTestWizard.abort.message.insufficient.slots") );
}else if ( not_choked_peers.size() == 0 && testMode!=TEST_TYPE_UPLOAD_ONLY){
abort( MessageText.getString("SpeedTestWizard.abort.message.not.unchoked") );
}
}
if ( !aborted ){
//calculate the measured download rate.
NetworkAdminSpeedTesterResult r = calculateDownloadRate();
lastResult = r;
// TODO: persist it
//Log the result.
AEDiagnosticsLogger diagLogger = AEDiagnostics.getLogger("v3.STres");
diagLogger.log(r.toString());
complete(r);
}
}finally{
synchronized( NetworkAdminSpeedTesterBTImpl.this ){
test_completed = true;
if ( deferred_abort != null ){
sendResultToListeners( new BitTorrentResult( deferred_abort ));
}
}
}
}//run.
/**
* Calculate the test progression as a value between 0-100.
* @param currTime - current time as long.
* @param stats - Download stats
*/
public void updateTestProgress(long currTime, DownloadStats stats){
//do two calculations. Frist based on the total time allowed for the test
long totalDownloadTimeUsed = currTime-startTime;
float percentTotal = ((float)totalDownloadTimeUsed/(float)MAX_TEST_TIME);
//second for the time since the peak value has been reached.
long totalTestTimeUsed = currTime-peakTime;
float percentDownload = ((float)totalTestTimeUsed/(float)MAX_PEAK_TIME);
//the larger of the two wins.
float reportedProgress = percentTotal;
if( percentDownload>reportedProgress )
reportedProgress=percentDownload;
int progressBarVal = Math.round( reportedProgress*100.0f );
StringBuffer msg = new StringBuffer("progress: ");
msg.append( progressBarVal );
//include the upload and download values.
msg.append(" : download ave ");
msg.append( stats.getDownloadAverage() );
msg.append(" : upload ave ");
msg.append( stats.getUploadAverage() );
msg.append(" : ");
int totalTimeLeft = (int)((MAX_TEST_TIME-totalDownloadTimeUsed)/1000);
msg.append(totalTimeLeft);
msg.append(" : ");
int testTimeLeft = (int)((MAX_PEAK_TIME-totalTestTimeUsed)/1000);
msg.append(testTimeLeft);
sendStageUpdateToListeners( msg.toString() );
}//updateTestProgress
/**
* Calculate the avererage and standard deviation for a history.
* @param history - List of Long values but that contains the sum downloaded at that time.
* @return Map<String,Double> with values "ave" and "stddev" set
*/
//Map<String,Double> calculate(List<Long> history)
private Map calculate(List history){
//convert the list of long values that sum the value into a list of deltas.
List deltas = convertSumToDeltas(history);
//sort
Collections.sort(deltas);
//remove the top and bottom 10% of the sample. This removes outliers from the mean.
final int nSamples = deltas.size();
final int nRemove = nSamples/10;
//removing high values.
for(int i=nSamples-1; i<nSamples-nRemove; i--){
deltas.remove(i);
}
//remove low values.
for(int i=0; i<nRemove; i++){
deltas.remove(0);
}
//sum values
long sumBytes=0;
int j=0;
while(j<deltas.size()){
sumBytes += autoboxLong( deltas.get(j) );
j++;
}
//calculate average.
double aveRate = (double) ( sumBytes/deltas.size() );
//Debug.out("ave rate:"+aveRate);
//calculate standard deviation.
double variance = 0.0;
double s;
for(j=0;j<deltas.size();j++){
//Debug.out( j+","+deltas.get(j) );
s = ( autoboxLong(deltas.get(j)) - aveRate );
variance += s*s;
}
double stddev = Math.sqrt( variance/(j-1) );
//Map<String,Double> retVal = new HashMap<String,Double>();
Map retVal = new HashMap();
retVal.put(AVE, autoboxDouble(aveRate));
retVal.put(STD_DEV,autoboxDouble(stddev));
return retVal;
}//calculate
/**
* Convert a list of sums into a list of download rates per second.
* @param sumHistory - List<Long> with download sum for each second.
* @return - List<Long> with the download rate for each second.
*/
private List convertSumToDeltas(List sumHistory){
//find the first element to inlcude in the stat.
int numStats = sumHistory.size();
int i = findIndexPeak(numStats);
List deltas = new ArrayList(numStats);
long prevSumDownload = autoboxLong(sumHistory.get(i-1));
long currSumDownload;
while(i<numStats){
currSumDownload = autoboxLong( sumHistory.get(i) );
Long currDelta = autoboxLong( currSumDownload - prevSumDownload );
deltas.add(currDelta);
i++;
prevSumDownload = currSumDownload;
}//while
return deltas;
}//convertSumToDeltas
private int findIndexPeak(int numStats) {
long thisTime;
int i;
for(i=0;i<numStats;i++ ){
thisTime = autoboxLong( timestamps.get(i) );
if(thisTime>peakTime){
break;
}
}//for
return i;
}
/**
* Based on the previous data cancluate an average and a standard deviation.
* Return this data in a Map object.
* @return Map<String,Float> as a contain for stats. Map keys are "ave" and "dev".
*/
NetworkAdminSpeedTesterResult calculateDownloadRate()
{
//calculate the BT download rate.
//Map<String,Double> resDown = calculate(historyDownloadSpeed);
Map resDown = calculate(historyDownloadSpeed);
//calculate the BT upload rate.
//Map<String,Double> resUp = calculate(historyUploadSpeed);
Map resUp = calculate(historyUploadSpeed);
return new BitTorrentResult(resUp,resDown);
}//calculateDownloadRate
/**
* In this version the test is limited to MAX_TEST_TIME since the start of the test
* of MAX_PEAK_TIME (i.e. time since the peak download rate has been reached). Which
* ever condition is first will finish the download.
* @return true if the test done condition has been reached.
*/
boolean checkForTestDone(){
long currTime = SystemTime.getCurrentTime();
//have we reached the max time for this test?
if( (currTime-startTime)>MAX_TEST_TIME ){
return true;
}
//have we been near the peak download value for max time?
return (currTime - peakTime) > MAX_PEAK_TIME;
}//checkForTestDone
/**
* We set a new "peak" value if it has exceeded the previous peak value by 10%.
* @param stat -
* @param lastTotalDownload -
* @param currTime -
* @return total downloaded so far.
*/
long checkForNewPeakValue(DownloadStats stat, long lastTotalDownload, long currTime)
{
//upload only used the "uploaded" data. The "download only" and "both" uses download.
long totTransferred;
if(testMode==TEST_TYPE_UPLOAD_ONLY){
totTransferred = stat.getUploaded();
}else{
totTransferred = stat.getDownloaded();
}
long currTransferRate = totTransferred-lastTotalDownload;
//if the current rate is 10% greater then the previous max, reset the max, and test timer.
if( currTransferRate > peakRate ){
peakRate = (long) (currTransferRate*1.1);
peakTime = currTime;
}
return totTransferred;
}//checkForNewPeakValue
}//class TorrentSpeedTestMonitorThread
class BitTorrentResult implements NetworkAdminSpeedTesterResult{
long time;
int downspeed;
int upspeed;
boolean hadError = false;
String lastError = "";
/**
* Build a Result for a successful test.
* @param uploadRes - Map<String,Double> of upload results.
* @param downloadRes - Map<String,Double> of download results.
*/
public BitTorrentResult(Map uploadRes, Map downloadRes){
time = SystemTime.getCurrentTime();
Double dAve = (Double)downloadRes.get(TorrentSpeedTestMonitorThread.AVE);
Double uAve = (Double)uploadRes.get(TorrentSpeedTestMonitorThread.AVE);
downspeed = dAve.intValue();
upspeed = uAve.intValue();
}
/**
* Build a Result if the test failed with an error.
* @param errorMsg - why the test failed.
*/
public BitTorrentResult(String errorMsg){
time = SystemTime.getCurrentTime();
hadError=true;
lastError = errorMsg;
}
public NetworkAdminSpeedTester getTest() {
return( NetworkAdminSpeedTesterBTImpl.this );
}
public long getTestTime() {
return time;
}
public int getDownloadSpeed() {
return downspeed;
}
public int getUploadSpeed() {
return upspeed;
}
public boolean hadError() {
return hadError;
}
public String getLastError() {
return lastError;
}
public String getResultString(){
StringBuffer sb = new StringBuffer();
//Time
SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmss z");
String d = format.format( new Date(time) );
sb.append(d).append(" ");
sb.append("type: BT test ");
//Get test info.
sb.append("mode: ").append( getMode() );
//Get crypto
sb.append(" encrypted: ");
if( use_crypto ){
sb.append("y");
}else{
sb.append("n");
}
if(hadError){
//Error
sb.append(" Last Error: ").append(lastError);
}else{
//Result
sb.append(" download speed: ").append(downspeed).append(" bits/sec");
sb.append(" upload speed: ").append(upspeed).append(" bits/sec");
}
return sb.toString();
}//getString
public String toString(){
StringBuffer sb = new StringBuffer("[com.aelitis.azureus.core.networkmanager.admin.impl.NetworkAdminSpeedTesterBTImpl");
sb.append(" ").append( getResultString() ).append(" ");
sb.append("]");
return sb.toString();
}
}//class BitTorrentResult
private static long autoboxLong(Object o){
return autoboxLong( (Long) o );
}
private static long autoboxLong(Long l){
return l.longValue();
}
private static Long autoboxLong(long l){
return new Long(l);
}
private static Double autoboxDouble(double d){
return new Double(d);
}
}//class
|
