package com.samknows.tests; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetSocketAddress; import java.net.Socket; import java.net.SocketException; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; import com.samknows.libcore.SKPorting; import org.json.JSONObject; // NOTE: This code is written as Pure Java. // It is possible to modify it to have Android-specific calls. // Look at the static methods at the top of the class, for the commented-out Android-specific // code that can be re-enabled if required. import com.samknows.libcore.SKPair; /* NOTES: See also https://svn.samknows.com/svn/tests/http_server/trunk/docs/protocol.txt ... where the protocol for the new service is defined. create socket connect ** Start by trying to do this in JUST ONE THREAD! ** boolean bQuit = false Thread 1: write header : Example header as follows: */ // POST /?CONTROL=1&UNITID=1&SESSIONID=281541010&NUM_CONNECTIONS=2&CONNECTION=1&AGGREGATE_WARMUP=0&RESULTS_INTERVAL_PERIOD=10&RESULT_NUM_INTERVALS=1&TEST_DATA_CAP=4294967295&TRANSFER_MAX_SIZE=4294967295&WARMUP_SAMPLE_TIME=5000&NUM_WARMUP_SAMPLES=1&MAX_WARMUP_SIZE=4294967295&MAX_WARMUP_SAMPLES=1&WARMUP_FAIL_ON_MAX=0&WARMUP_TOLERANCE=5 HTTP/1.1 // Host: n1-the1.samknows.com:6500 // Accept: */* // Content-Length: 4294967295 // Content-Type: application/x-www-form-urlencoded // Expect: 100-continue /* } The server expects a query string with a "CONTROL" field. It's value should be set to "1.0", which specifies the version of the protocol. - UNITID Mandatory. - SESSIONID Mandatory. - NUM_CONNECTIONS Mandatory. - CONNECTION Mandatory. - WARMUP_SAMPLE_TIME Mandatory for POST requests. - NUM_WARMUP_SAMPLES Mandatory for POST requests. - MAX_WARMUP_SAMPLES Mandatory for POST requests. - WARMUP_TOLERANCE Mandatory for POST requests. - RESULTS_INTERVAL_PERIOD Mandatory for POST requests. - RESULT_NUM_INTERVALS Mandatory for POST requests. - AGGREGATE_WARMUP Optional. Default: false. - TEST_DATA_CAP Optional. Default: no limit. - TRANSFER_MAX_SIZE Optional. Default: no limit. - MAX_WARMUP_SIZE Optional. Default: no limit. - WARMUP_FAIL_ON_MAX Optional. Default: false. - TRACE_INTERVAL Optional. Default: no tracing. - TCP_CONG Optional. Default: server system default. The values must be sent to the server (e.g TEST_DATA_CAP). Once the server reaches the limits it will send the result up to that point. This makes the limit "maximum bytes to *RECEIVE*". To keep it as "maximum bytes to *SENT*" you could keep your own counter and close the connection when you have sent a fixed amount of bytes... } while (bQuit == false) { write(socket, buffer...) } Thread 2: while (bQuit == false) { if (read (socket, intobuffer, timeout)) succeeds: { Extract upload speed results from server response, which will be in this format: SAMKNOWS_HTTP_REPLY\n VERSION: <major>.<minor>\n RESULT: <OK|FAIL>\n END_TIME: <end time> SECTION: WARMUP\n NUM_WARMUP: <num>\n WARMUP_SESSION <seconds> <nanoseconds> <bytes>\n WARMUP_SESSION <seconds> <nanoseconds> <bytes>\n SECTION: MEASUR\n NUM_MEASUR: <num>\n MEASUR_SESSION <seconds> <nanoseconds> <bytes>\n MEASUR_SESSION <seconds> <nanoseconds> <bytes>\n In terms of sample data etc., the server will give you something like this: ... NUM_MEASUR: 2\n MEASUR_SESSION 5 0 5000000\n MEASUR_SESSION 10 0 15000000\n ... ... It's the client job to calculate that during the first five seconds the speed has been 5,000,000 / 5 = 1,000,000 bytes/sec; and during the next 10 seconds 15,000,000 / 10 = 1,500,000 bytes/sec. Meaning that the speed between seconds 5 and 10 has been (15,000,000 - 5,000,000) / (10 - 5) = 2,000,000 bytes/sec. ... send this "final upload speed result value from the server" to the application. bQuit = true; } } */ public abstract class HttpTest extends SKAbstractBaseTest implements Runnable { // @property (weak) SKTransferOperation *mpParentTransferOperation; // @property int mSocketFd; public enum UploadStrategy {ACTIVE, PASSIVE} // Socket timeout parameters private final int CONNECTIONTIMEOUT = 10000; // 10 seconds connection timeout private final int READTIMEOUT = 10000; // 10 seconds read timeout private final int WRITETIMEOUT = 10000; // 10 seconds write timeout // Http Status codes protected final int HTTPOK = 200; private final int HTTPCONTINUE = 100; // error codes and constraints protected final int BYTESREADERR = -1; // Error occurred while reading from socket private final int MAXNTHREADS = 100; // Max number of threads // Parameters name for the setParameter function. // HTTP test types. Static because called from constructors. protected final static String _DOWNSTREAM = "downstream"; protected final static String _UPSTREAM = "upstream"; // Parameters names for use in Settings XML files //private static final String DOWNSTREAM = "downStream"; //private static final String UPSTREAM = "upStream"; private static final String UPLOADSTRATEGY = "strategy"; // Use server side calculations, different type of server required public static final String WARMUPMAXTIME = "warmupMaxTime"; // Max warmup time in uSecs private static final String WARMUPMAXBYTES = "warmupMaxBytes"; // Max warmup bytes allowed to be transmitted public static final String TRANSFERMAXTIME = "transferMaxTime"; // Max transfer time in uSecs. Metrics, measured during this time period contribute to final result private static final String TRANSFERMAXBYTES = "transferMaxBytes"; // Max transfer bytes allowed to be transmitted public static final String NTHREADS = "numberOfThreads"; // Max number of threads allowed private static final String NTHREADSLOWERCASE = "numberofthreads"; // Max number of threads allowed public static final String BUFFERSIZE = "bufferSize"; // Socket receive buffer size public static final String SENDBUFFERSIZE = "sendBufferSize"; // Socket send buffer size private static final String RECEIVEBUFFERSIZE = "receiveBufferSize";// Socket receive buffer size private static final String POSTDATALENGTH = "postDataLength"; // ??? public static final String SENDDATACHUNK = "sendDataChunk"; // Application send buffer size // Messages regarding the status of the test private final String HTTPGETRUN = "Running download test"; private final String HTTPGETDONE = "Download test completed"; private final String HTTPPOSTRUN = "Running upload test"; private final String HTTPPOSTDONE = "Upload completed"; // Test strings for public use. JSON related public static final String DOWNSTREAMSINGLE = "JHTTPGET"; public static final String DOWNSTREAMMULTI = "JHTTPGETMT"; public static final String UPSTREAMSINGLE = "JHTTPPOST"; public static final String UPSTREAMMULTI = "JHTTPPOSTMT"; // "Direction" for constructor public static final String cReasonResetDownload = "Reset Download"; public static final String cReasonResetUpload = "Reset Upload"; public static final String cReasonUploadEnd = "Upload End"; // Create an interface class, which will allow us to inject a test socket for mock testing. // Usage: Call open, then the set/get methods - then connect! // Then call getInputStream/getOutputStream... // Then call close() public interface ISKHttpSocketFactory { // Instance of factory used to "open" the socket, as a wrapper around the open method. // If null, we use the standard SKHttpSocket. ISKHttpSocket newSocket(); } public interface ISKHttpSocket { void open(); void setTcpNoDelay(boolean on) throws SocketException; void setReceiveBufferSize(int size) throws SocketException; int getReceiveBufferSize() throws SocketException; void setSendBufferSize(int size) throws SocketException; int getSendBufferSize() throws SocketException; void setSoTimeout(int timeout) throws SocketException; //ipAddress = sockAddr.getAddress().getHostAddress(); // Returns the ipaddress... String connect(String target, int port, int timeout) throws IOException; InputStream getInputStream() throws IOException; OutputStream getOutputStream() throws IOException; void close() throws IOException; } // Define a real instantiation of the ISKHttpSocket interface, which is used for "real" testing. public class SKHttpSocket implements ISKHttpSocket { private Socket socket = null; public SKHttpSocket() { } public void open() { socket = new Socket(); } public void setTcpNoDelay(boolean on) throws SocketException { if (socket == null) { SKPorting.sAssert(false); return; } socket.setTcpNoDelay(on); } public synchronized void setReceiveBufferSize(int size) throws SocketException { if (socket == null) { SKPorting.sAssert(false); return; } socket.setReceiveBufferSize(size); } public int getReceiveBufferSize() throws SocketException { if (socket == null) { SKPorting.sAssert(false); return 0; } return socket.getReceiveBufferSize(); } public synchronized void setSendBufferSize(int size) throws SocketException { if (socket == null) { SKPorting.sAssert(false); return; } socket.setSendBufferSize(size); } public synchronized int getSendBufferSize() throws SocketException { if (socket == null) { SKPorting.sAssert(false); return 0; } return socket.getSendBufferSize(); } public void setSoTimeout(int timeout) throws SocketException { if (socket == null) { SKPorting.sAssert(false); return; } socket.setSoTimeout(timeout); } // Returns the ipaddress... public String connect(String target, int port, int timeout) throws IOException { InetSocketAddress sockAddr = new InetSocketAddress(target, port); if (sockAddr == null) { SKPorting.sAssert(false); return ""; } socket.connect(sockAddr, timeout); // // 10 seconds connection timeout return sockAddr.getAddress().getHostAddress(); } public InputStream getInputStream() throws IOException { if (socket == null) { SKPorting.sAssert(false); return null; } return socket.getInputStream(); } public OutputStream getOutputStream() throws IOException { if (socket == null) { SKPorting.sAssert(false); return null; } return socket.getOutputStream(); } public void close() throws IOException { if (socket == null) { SKPorting.sAssert(false); return; } try { socket.close(); } catch (IOException e1) { SKPorting.sAssert(false); throw e1; } finally { socket = null; } } // public long getStartTimeNanoseconds() { // return System.nanoTime(); // } // // public long getTimeNowNanoseconds() { // return System.nanoTime(); // } // // public InetAddress getInetAddressByName(String host) throws UnknownHostException { // return InetAddress.getByName(host); // } } private String TAG(Object param) { return param.getClass().getSimpleName(); } /* TAG is to be passed to SKLogger class. It outputs the human readable class name of the message logger */ /* Abstract methods to be implemented in derived classes */ protected abstract boolean transfer(ISKHttpSocket socket, int threadIndex); /* Generate main traffic for metrics measurements */ protected abstract boolean warmup(ISKHttpSocket socket, int threadIndex); /* Generate initial traffic for setting optimal TCP parameters */ //private abstract int getWarmupBytesPerSecond(); /* Initial traffic speed */ //private abstract int getTransferBytesPerSecond(); /* Main traffic speed */ private Thread[] mThreads = null; /* Array of all running threads */ /* Time helper functions */ protected long sGetMicroTime() { return System.nanoTime() / 1000L; } private long sGetMilliTime() { return System.nanoTime() / 1000000L; } protected HttpTest(String direction, List<Param> params) { /* Constructor. Accepts list of Param objects, each representing a certain parameter read from settings XML file */ setDirection(direction); /* Legacy. To be removed */ sLatestSpeedReset(downstream ? cReasonResetDownload : cReasonResetUpload); setParams(params); /* Initialisation */ //SKLogger.d(this, "CREATING HTTP TEST - LOG TEST!"); } private void setParams(List<Param> params) { /* Initialisation helper function */ initialised = true; try { for (Param param : params) { String value = param.getValue(); if (param.contains(TARGET)) { target = value; } else if (param.contains(PORT)) { port = Integer.parseInt(value); } else if (param.contains(FILE)) { file = value; } else if (param.contains(WARMUPMAXTIME)) { mWarmupMaxTimeMicro = Integer.parseInt(value); } else if (param.contains(WARMUPMAXBYTES)) { mWarmupMaxBytes = Integer.parseInt(value); } else if (param.contains(TRANSFERMAXTIME)) { mTransferMaxTimeMicro = Integer.parseInt(value); } else if (param.contains(TRANSFERMAXBYTES)) { mTransferMaxBytes = Integer.parseInt(value); } else if (param.contains(NTHREADS)) { nThreads = Integer.parseInt(value); } else if (param.contains(NTHREADSLOWERCASE)) { nThreads = Integer.parseInt(value); } else if (param.contains(UPLOADSTRATEGY)) { uploadStrategyServerBased = UploadStrategy.ACTIVE; /* If strategy parameter is present ActiveServerload class is used */ } else if (param.contains(BUFFERSIZE)) { downloadBufferSize = Integer.parseInt(value); } else if (param.contains(SENDBUFFERSIZE)) { socketBufferSize = Integer.parseInt(value); } else if (param.contains(RECEIVEBUFFERSIZE)) { desiredReceiveBufferSize = Integer.parseInt(value); downloadBufferSize = Integer.parseInt(value); } else if (param.contains(SENDDATACHUNK)) { uploadBufferSize = Integer.parseInt(value); } else if (param.contains(POSTDATALENGTH)) { postDataLength = Integer.parseInt(value); } else { SKPorting.sLogE("HttpTest", "setParams()"); initialised = false; break; } } } catch (NumberFormatException nfe) { SKPorting.sAssert(false); initialised = false; } } @Override public int getNetUsage() { /* Total number of bytes transfered */ return (int) (getTotalTransferBytes() + getTotalWarmUpBytes()); } // @SuppressLint("NewApi") @Override public boolean isReady() { /* Test sanity checker. Virtual */ if (!initialised) return false; if (target.length() == 0) { setError("Target empty"); return false; } if (port == 0) { setError("Port is zero"); return false; } if (mWarmupMaxTimeMicro == 0 && mWarmupMaxBytes == 0) { setError("No warmup parameter defined"); return false; } if (mTransferMaxTimeMicro == 0 && mTransferMaxBytes == 0) { setError("No transfer parameter defined"); return false; } if (downstream && downloadBufferSize == 0) { setError("Buffer size missing for download"); return false; } if (nThreads < 1 && nThreads > MAXNTHREADS) { setError("Number of threads error, current is: " + nThreads + ". Min " + 1 + " Max " + MAXNTHREADS + "."); return false; } return true; } // void sendTestPing(String token) { // // // DatagramSocket socket = null; // try { // socket = new DatagramSocket(); // // try { // InetAddress address = InetAddress.getByName("192.168.2.105"); // byte[] buf = token.getBytes(Charset.forName("UTF-8")); // DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 90); // socket.send(packet); // } catch (Exception e) { // sAssert(false); // } // } catch (SocketException e2) { // socket.close(); // sAssert(false); // } finally { // if (socket != null) { // socket.close(); // } // } // } @Override public boolean isSuccessful() { return testStatus.equals("OK"); } /* Returns test run result */ // public int getSendBufferSize() { return sendBufferSize; } // public int getReceiveBufferSize() { return receiveBufferSize; } // public String getInfo() { return infoString; } // Socket factory to support testing! ISKHttpSocketFactory mThisSocketFactory = null; @Override public void runBlockingTestToFinishInThisThread() { /* Execute test */ //smDebugSocketSendTimeMicroseconds.clear(); //Context context = SKApplication.getAppInstance().getBaseContext(); //sendTestPing("TIMING_Start"); if (downstream) { //SKLogger.d(this, "DOWNLOAD HTTP TEST - execute()"); infoString = HTTPGETRUN; } else { //SKLogger.d(this, "UPLOAD HTTP TEST - execute()"); infoString = HTTPPOSTRUN; } setStateToRunning(); mThreads = new Thread[nThreads]; for (int i = 0; i < nThreads; i++) { mThreads[i] = new Thread(this); } for (int i = 0; i < nThreads; i++) { mThreads[i].start(); } try { for (int i = 0; i < nThreads; i++) { mThreads[i].join(); } } catch (Exception e) { setErrorIfEmpty("Thread join exception: ", e); SKPorting.sLogE("HttpTest", "Thread join exception()"); testStatus = "FAIL"; } if (downstream) { infoString = HTTPGETDONE; } else { infoString = HTTPPOSTDONE; } //sendTestPing("TIMING_Stop"); if (getTotalTransferBytes() == 0) { // 30/03/2015 - note that if transferBytes is ZERO, we must also tag this with "success": false error.set(true); } finish(); } public void runBlockingTestToFinishInThisThread(ISKHttpSocketFactory withThisSocketFactory) { /* Execute test */ if (mThisSocketFactory != null) { SKPorting.sAssert(false); } else { mThisSocketFactory = withThisSocketFactory; } runBlockingTestToFinishInThisThread(); } private ISKHttpSocket makeSocket() { /* Socket initialiser */ //SKLogger.d(this, "HTTP TEST - makeSocket()"); ISKHttpSocket retSocket = null; try { // Are we using a socket factory? if (mThisSocketFactory != null) { // Yes, use a specific socket factory (for testing!) retSocket = mThisSocketFactory.newSocket(); } else { // No, use the built-in socket. retSocket = new SKHttpSocket(); } retSocket.open(); retSocket.setTcpNoDelay(noDelay); if (0 != desiredReceiveBufferSize) { retSocket.setReceiveBufferSize(desiredReceiveBufferSize); } receiveBufferSize = retSocket.getReceiveBufferSize(); // Experimentation shows a *much* better settling-down on upload speed, // if we force a 32K send buffer size in bytes, rather than relying // on the default send buffer size. // When forcing value in bytes, you must actually divide by two! // https://code.google.com/p/android/issues/detail?id=13898 // desiredSendBufferSize = 32768 / 2; // (2 ^ 15) / 2 if (0 != socketBufferSize) { retSocket.setSendBufferSize(socketBufferSize); } sendBufferSize = retSocket.getSendBufferSize(); if (downstream) { // Read / download retSocket.setSoTimeout(READTIMEOUT); } else { retSocket.setSoTimeout(getSocketTimeoutMilliseconds()); //retSocket.setSoTimeout(1); } ipAddress = retSocket.connect(target, port, CONNECTIONTIMEOUT); // // 10 seconds connection timeout SKPorting.sAssert(ipAddress.length() > 0); //SKLogger.d(this, "HTTP TEST - getSocket() completed OK"); } catch (Exception e) { SKPorting.sLogE("HttpTest", "getSocket()", e); retSocket = null; } return retSocket; } private Long mTimestampSeconds = SKAbstractBaseTest.sGetUnixTimeStampSeconds(); @Override public synchronized void finish() { mTimestampSeconds = SKAbstractBaseTest.sGetUnixTimeStampSeconds(); status = STATUS.DONE; } @Override public long getTimestamp() { return mTimestampSeconds; } @Override public void setTimestamp(long timestamp) { mTimestampSeconds = timestamp; } @Override public JSONObject getJSONResult() { //SKLogger.d(this, "HTTP TEST - output()"); Map<String, Object> output = new HashMap<>(); // string id output.put(JsonData.JSON_TYPE, getStringID()); // time output.put(JsonData.JSON_TIMESTAMP, mTimestampSeconds); output.put(JsonData.JSON_DATETIME, SKPorting.sGetDateAsIso8601String(new java.util.Date(mTimestampSeconds * 1000))); long transferBytes = getTotalTransferBytes(); //SKLogger.d(this, "HTTP TEST - output(), transferBytes=" + transferBytes); if (transferBytes == 0) { // 30/03/2015 - note that if transferBytes is ZERO, we must also tag this with "success": false error.set(true); } // status if (error.get()) { output.put(JsonData.JSON_SUCCESS, false); } else { output.put(JsonData.JSON_SUCCESS, true); } // target output.put(JsonData.JSON_TARGET, target); // target ip address output.put(JsonData.JSON_TARGET_IPADDRESS, ipAddress); // transfer time output.put(JsonData.JSON_TRANFERTIME, getTransferTimeMicro()); // transfer bytes output.put(JsonData.JSON_TRANFERBYTES, totalTransferBytes); // byets_sec output.put(JsonData.JSON_BYTES_SEC, Math.max(0, getTransferBytesPerSecond())); // warmup time output.put(JsonData.JSON_WARMUPTIME, getWarmUpTimeMicro()); // warmup bytes output.put(JsonData.JSON_WARMUPBYTES, getTotalWarmUpBytes()); // number of threads output.put(JsonData.JSON_NUMBER_OF_THREADS, nThreads); JSONObject json_output = new JSONObject(output); return json_output; } /* The following set of methods relates to a communication with the external UI TODO move prototypes to test */ static private AtomicReference<Double> sLatestSpeedForExternalMonitorBytesPerSecond = new AtomicReference<>(Double.valueOf(0.0)); static private AtomicReference<Double> sBytesPerSecondLast = new AtomicReference<>(Double.valueOf(0.0)); private static String sLatestSpeedForExternalMonitorTestId = ""; private static void sLatestSpeedReset(String theReasonId) { sLatestSpeedForExternalMonitorBytesPerSecond.set(Double.valueOf(0)); sBytesPerSecondLast.set(Double.valueOf(0)); sLatestSpeedForExternalMonitorTestId = theReasonId; } public static void sLatestSpeedReset() { sLatestSpeedReset(cReasonResetDownload); } // Report-back a running average, to keep the UI moving... // Returns -1 if sample time too short. public static SKPair<Double, String> sGetLatestSpeedForExternalMonitorAsMbps() { // use moving average of the last 2 items! double bytesPerSecondToUse = sBytesPerSecondLast.get().doubleValue() + sLatestSpeedForExternalMonitorBytesPerSecond.get().doubleValue(); bytesPerSecondToUse /= 2; double mbps1000Based = Conversions.sConvertBytesPerSecondToMbps1000Based(bytesPerSecondToUse); return new SKPair<>(mbps1000Based, sLatestSpeedForExternalMonitorTestId); } public static void sSetLatestSpeedForExternalMonitor(Double bytesPerSecond, String testId) { sBytesPerSecondLast = sLatestSpeedForExternalMonitorBytesPerSecond; if (bytesPerSecond == 0) { //sAssert(testId.equals(cReasonUploadEnd)); } sLatestSpeedForExternalMonitorBytesPerSecond.set(bytesPerSecond); sLatestSpeedForExternalMonitorTestId = testId; } protected final int extMonitorUpdateInterval = 500000; protected void sSetLatestSpeedForExternalMonitorInterval(long pause, String id, Double transferSpeed) { long updateTime = /*timeElapsedSinceLastExternalMonitorUpdate.get() == 0 ? pause * 5 : */ pause; /* first update is delayed 3 times of a given pause */ if (timeElapsedSinceLastExternalMonitorUpdate.get() == 0) { timeElapsedSinceLastExternalMonitorUpdate.set(sGetMicroTime()); /* record update time */ } if (sGetMicroTime() - timeElapsedSinceLastExternalMonitorUpdate.get() > updateTime/*uSec*/) { /* update should be called only if 'pause' is expired */ double currentSpeed; try { currentSpeed = transferSpeed; /* current speed could be for warm up, transfer or possibly others processes */ } catch (Exception e) { currentSpeed = 0.0; } sSetLatestSpeedForExternalMonitor(currentSpeed /*/ 1000000.0*/, id); /* update speed parameter + indicative ID */ timeElapsedSinceLastExternalMonitorUpdate.set(sGetMicroTime()); /* set new update time */ // SKLogger.d(TAG(this), "External Monitor updated at " + (new java.text.SimpleDateFormat("HH:mm:ss.SSS")).format(new java.util.Date()) + // " as " + ( currentSpeed / 1000000.0) + // " thread: " + getThreadIndex());//haha remove in production } } /* This is the end of the block related to communication with UI */ protected boolean isWarmupDone(int bytes) { //SKLogger.d(this, "isWarmupDone("+ bytes+")"); boolean timeExceeded = false; boolean bytesExceeded = false; if (bytes == BYTESREADERR) { /* if there is an error the test must stop and report it */ setErrorIfEmpty("read error"); bytes = 0; /* do not modify the bytes counters ??? */ error.set(true); return true; } if (mWarmupMicroDuration.get() != 0) /* if some other thread has already finished warmup there is no need to proceed */ return true; addTotalWarmUpBytes(bytes); /* increment atomic total bytes counter */ if (mStartWarmupMicro.get() == 0) { mStartWarmupMicro.set(sGetMicroTime()); /* record start up time should be recorded only by one thread */ } setWarmUpTimeMicro(sGetMicroTime() - mStartWarmupMicro.get()); /* current warm up time should be atomic*/ if (mWarmupMaxTimeMicro > 0) { /*if warmup max time is set and time has exceeded its values set time warmup to true */ timeExceeded = (mWarmupTimeMicro.get() >= mWarmupMaxTimeMicro); } if (mWarmupMaxBytes > 0) { /* if warmup max bytes is set and bytes counter exceeded its value set bytesWarmup to true */ bytesExceeded = (getTotalWarmUpBytes() >= mWarmupMaxBytes); } if (timeExceeded) { /* if maximum warmup time is reached */ if (mWarmupMicroDuration.get() == 0) { mWarmupMicroDuration.set(sGetMicroTime() - mStartWarmupMicro.get()); /* Register the time duration up to this moment */ } warmupDoneCounter.addAndGet(1); /* and increment warmup counter */ return true; } if (bytesExceeded) { /* if max warmup bytes transferred */ if (mWarmupMicroDuration.get() == 0) { mWarmupMicroDuration.set(sGetMicroTime() - mStartWarmupMicro.get()); /* Register the time duration up to this moment */ } warmupDoneCounter.addAndGet(1); /* and increment warmup counter */ return true; } return false; } protected boolean isTransferDone(int bytes) { boolean timeExceeded = false; boolean bytesExceeded = false; //SKLogger.d(this, "isTransferDone("+ bytes+")"); //boolean ret = false; if (bytes == BYTESREADERR) { /* if there is an error the test must stop and report it */ setErrorIfEmpty("read error"); bytes = 0; /* do not modify the bytes counters ??? */ error.set(true); SKPorting.sLogE("HttpTest", "isTransferDone, bytes == BYTESREADERR!"); return true; } if (mTransferMicroDuration.get() != 0) { /* if some other thread has already finished warmup there is no need to proceed */ //SKLogger.d(this, "isTransferDone, mTransferMicroDuration != 0"); return true; } addTotalTransferBytes(bytes); /* increment atomic total bytes counter */ /* record start up time should be recorded only by one thread */ mStartTransferMicro.compareAndSet(0, sGetMicroTime()); //SKLogger.d(TAG(this), "Setting transfer start == " + mStartTransferMicro.get() + " by thread: " + this.getThreadIndex());//TODO remove in production setTransferTimeMicro(sGetMicroTime() - mStartTransferMicro.get()); /* How much time transfer took up to now */ if (mTransferMaxTimeMicro > 0) { /* If transfer time is more than max time, then transfer is done */ //SKLogger.d(this, "transfer Time so far milli =" + getTransferTimeMicro()/1000); timeExceeded = (getTransferTimeMicro() >= mTransferMaxTimeMicro); } //SKLogger.d(this, "transfer Bytes so far =" + getTotalTransferBytes()); if (mTransferMaxBytes > 0) { bytesExceeded = (getTotalTransferBytes() >= mTransferMaxBytes); } if (getTotalTransferBytes() > 0) { testStatus = "OK"; } if (timeExceeded) { /* if maximum transfer time is reached */ /* Register the time duration up to this moment */ mTransferMicroDuration.compareAndSet(0, sGetMicroTime() - mStartTransferMicro.get()); transferDoneCounter.addAndGet(1); /* and increment transfer counter */ //SKLogger.d(this, "isTransferDone, timeExceeded"); return true; } if (bytesExceeded) { /* if max transfer bytes transferred */ mTransferMicroDuration.compareAndSet(0, sGetMicroTime() - mStartTransferMicro.get()); //SKLogger.d(this, "isTransferDone, bytesExceeded"); transferDoneCounter.addAndGet(1); /* and increment transfer counter */ return true; } //SKLogger.d(this, "isTransferDone, still waiting..."); return false; } protected int getThreadIndex() { int threadIndex = 0; synchronized (mThreads) { boolean bFound = false; int i; for (i = 0; i < mThreads.length; i++) { if (Thread.currentThread() == mThreads[i]) { threadIndex = i; bFound = true; break; } } if (bFound == false) { SKPorting.sLogE("HttpTest", "getThreadIndex()"); } } return threadIndex; } protected OutputStream getOutput(ISKHttpSocket socket) { OutputStream conn = null; boolean err = false; /*Initially there is not error */ if (socket != null) { try { conn = socket.getOutputStream(); /* Try to get output stream */ } catch (IOException io) { err = true; /* Fails */ SKPorting.sLogE("HttpTest", "getOutput() ... thread: " + this.getThreadIndex(), io); } } else { /* if socket is null - fails */ err = true; SKPorting.sLogE("HttpTest", "getOutput(), socket is null! ... thread: " + this.getThreadIndex()); } if (err) { /* return null if there is an error */ SKPorting.sLogE("HttpTest", "Error occurred while getting output connection, returning null... thread: " + this.getThreadIndex()); return null; } return conn; /* return output stream */ } protected InputStream getInput(ISKHttpSocket socket) { InputStream conn = null; boolean err = false; /*Initially there is not error */ if (socket != null) { try { conn = socket.getInputStream(); /* Try to get output stream */ } catch (IOException io) { err = true; /* Fails */ SKPorting.sLogE("HttpTest", "getInput() ... thread: " + this.getThreadIndex(), io); } } else { /* if socket is null - fails */ err = true; SKPorting.sLogE("HttpTest", "getOutput(), socket is null! ... thread: " + this.getThreadIndex()); } if (err) { /* return null if there is an error */ SKPorting.sLogE("HttpTest", "Error occurred while getting input connection, returning null... thread: " + this.getThreadIndex()); return null; } return conn; /* return output stream */ } //public void setDownstream() { downstream = true; } //public void setUpstream() { downstream = false; } private void setDirection(String d) { if (d.equalsIgnoreCase(_DOWNSTREAM)) { downstream = true; } else if (d.equalsIgnoreCase(_UPSTREAM)) { downstream = false; } } public boolean isProgressAvailable() {//TODO check with new interface boolean ret = false; if (mTransferMaxTimeMicro > 0) { ret = true; } else if (mTransferMaxBytes > 0) { ret = true; } return ret; } // Return progress as integer value from 0 to 100. public int getProgress0To100() { double ret = 0; if (mStartWarmupMicro.get() == 0) { return 0; } if (mTransferMaxTimeMicro != 0) { long currTime = sGetMicroTime() - mStartWarmupMicro.get(); ret = (double) currTime / (mWarmupMaxTimeMicro + mTransferMaxTimeMicro); } else { long currBytes = getTotalWarmUpBytes() + getTotalTransferBytes(); ret = (double) currBytes / (mWarmupMaxBytes + mTransferMaxBytes); } int result = (int) (ret * 100); if (result < 0) { return 0; } if (result > 100) { return 100; } SKPorting.sAssert(result >= 0); SKPorting.sAssert(result <= 100); return result; } protected void closeConnection(ISKHttpSocket socket) { /* Closes connections and winds socket out*/ //SKLogger.d(this, "closeConnection()"); /* * Should be run inside thread */ if (socket != null) { OutputStream outputStream = null; InputStream inputStream = null; try { outputStream = socket.getOutputStream(); inputStream = socket.getInputStream(); } catch (IOException e) { SKPorting.sLogE("HttpTest", "closeConnection(), e", e); } if (inputStream != null) { //SKLogger.d(this, "inputStream.close()"); try { inputStream.close(); } catch (IOException ioe) { SKPorting.sLogE("HttpTest", "closeConnection(), ioe", ioe); } } if (outputStream != null) { //SKLogger.d(this, "outputStream.close()"); try { outputStream.close(); } catch (IOException ioe2) { SKPorting.sLogE("HttpTest", "closeConnection(), ioe2", ioe2); } } try { //SKLogger.d(this, "socket.close()"); socket.close(); } catch (IOException ioe3) { SKPorting.sLogE("HttpTest", "closeConnection(), ioe2", ioe3); } } } @Override public void run() { boolean result = false; int threadIndex = getThreadIndex(); ISKHttpSocket socket = makeSocket(); if (socket == null) { SKPorting.sLogE("HttpTest", "Socket initiation failed, thread: " + threadIndex); return; } result = warmup(socket, threadIndex); if (!result) { closeConnection(socket); return; } result = transfer(socket, threadIndex); closeConnection(socket); } /* * Atomic variables used as aggregate counters or (errors, etc. ) indicators updated from concurrently running threads */ private AtomicLong totalWarmUpBytes = new AtomicLong(0); /* Total num of bytes transmitted during warmup period */ private AtomicLong totalTransferBytes = new AtomicLong(0); /* Total num of bytes transmitted during trnasfer period */ private AtomicBoolean error = new AtomicBoolean(false); /* Global error indicator */ protected AtomicBoolean getError() { return error; } /* * Accessors to atomic variables */ protected long getTotalWarmUpBytes() { return totalWarmUpBytes.get(); } protected long getTotalTransferBytes() { return totalTransferBytes.get(); } protected long getWarmUpTimeMicro() { return mWarmupTimeMicro.get(); } private long getWarmUpTimeDurationMicro() { return mWarmupMicroDuration.get(); } protected long getTransferTimeMicro() { return transferTimeMicroseconds.get(); } private long getTransferTimeDurationMicro() { return mTransferMicroDuration.get(); } private long getStartTransferMicro() { return mStartTransferMicro.get(); } private long getStartWarmupMicro() { return mStartWarmupMicro.get(); } protected void addTotalTransferBytes(long bytes) { totalTransferBytes.addAndGet(bytes); } protected void resetTotalTransferBytesToZero() { totalTransferBytes.set(0L); } private void addTotalWarmUpBytes(long bytes) { totalWarmUpBytes.addAndGet(bytes); } private void setWarmUpTimeMicro(long uTime) { mWarmupTimeMicro.set(uTime); } private void setTransferTimeMicro(long uTime) { transferTimeMicroseconds.set(uTime); } private String infoString = ""; private String ipAddress = ""; private boolean randomEnabled = false; /* Upload buffer randomisation is required */ protected boolean getRandomEnabled() { return randomEnabled; } //boolean warmUpDone = false; private int postDataLength = 0; protected int getPostDataLength() { return postDataLength; } // warmup variables private AtomicLong mStartWarmupMicro = new AtomicLong(0); /* Point in time when warm up process starts, uSecs */ private AtomicLong mWarmupMicroDuration = new AtomicLong(0); /* Total duration of warm up period, uSecs */ private AtomicLong mWarmupTimeMicro = new AtomicLong(0); /* Time elapsed since warm up process started, uSecs */ private AtomicInteger warmupDoneCounter = new AtomicInteger(0); /* Counter shows how many threads completed warm up process */ private long mWarmupMaxTimeMicro = 0; /* Max time warm up is allowed to continue, uSecs */ protected long getWarmupMaxTimeMicro() { return mWarmupMaxTimeMicro; } private int mWarmupMaxBytes = 0; /* Max bytes warm up is allowed to send */ protected int getWarmupMaxBytes() { return mWarmupMaxBytes; } // transfer variables private AtomicLong mStartTransferMicro = new AtomicLong(0); /* Point in time when transfer process starts, uSecs */ private AtomicLong mTransferMicroDuration = new AtomicLong(0); /* Total duration of transfer period, uSecs */ private AtomicLong transferTimeMicroseconds = new AtomicLong(0); /* Time elapsed since transfer process started, uSecs */ private AtomicInteger transferDoneCounter = new AtomicInteger(0); /* Counter shows how many threads completed trnasfer process */ private long mTransferMaxTimeMicro = 0; /* Max time transfer is allowed to continue, uSecs*/ protected long getTransferMaxTimeMicro() { return mTransferMaxTimeMicro; } private int mTransferMaxBytes = 0; /* Max bytes transfer is allowed to send */ protected int getTransferMaxBytes() { return mTransferMaxBytes; } //external monitor variables private AtomicLong timeElapsedSinceLastExternalMonitorUpdate = new AtomicLong(0); /* Time elapsed since external monitor counter was updated last time, uSecs */ // Various HTTP tests variables private int nThreads; /* Number of send/receive threads */ //various buffers private int downloadBufferSize = 0; protected int getDownloadBufferSize() { return downloadBufferSize; } private int desiredReceiveBufferSize = 0; private int socketBufferSize = 0; private int uploadBufferSize = 0; protected int getUploadBufferSize() { return uploadBufferSize; } //private int connectionCounter = 0; private int receiveBufferSize = 0; private int sendBufferSize = 0; protected int getThreadsNum() { return nThreads; } /* Accessor for number of threads */ private boolean noDelay = false; private String testStatus = "FAIL"; /* Test status, could be 'OK' or 'FAIL' */ protected String getTestStatus() { return testStatus; } protected void setTestStatus(String value) { testStatus = value; } // Connection variables private String target = ""; public String getTarget() { return target; } private String file = ""; protected String getFile() { return file; } private int port = 0; protected int getPort() { return port; } private UploadStrategy uploadStrategyServerBased = UploadStrategy.PASSIVE; /* Upload type selection strategy: simple upload or with server side measurements */ private boolean downstream = true; private static double sGetBytesPerSecondWithMicroDuration(long durationMicro, long btsTotal) { double btsPerSec = 0; if (durationMicro != 0) { double timeSeconds = ((double) durationMicro) / 1000000.0; btsPerSec = (((double) btsTotal) / timeSeconds); } //SKLogger.d(TAG(this), "getWarmupSpeedBytesPerSecond, using CLIENT value = " + btsPerSec);//HAHA remove in production return btsPerSec; } protected double getWarmupBytesPerSecond() { long btsTotal = getTotalWarmUpBytes(); long durationMicro = getWarmUpTimeDurationMicro() == 0 ? (sGetMicroTime() - getStartWarmupMicro()) : getWarmUpTimeDurationMicro(); return sGetBytesPerSecondWithMicroDuration(durationMicro, btsTotal); } // Returns -1 if not enough time has passed for sensible measurement. public double getTransferBytesPerSecond() { long btsTotal = getTotalTransferBytes(); long durationMicro = getTransferTimeDurationMicro() == 0 ? (sGetMicroTime() - getStartTransferMicro()) : getTransferTimeDurationMicro(); // double durationSeconds = ((double)durationMicro) / 1000000.0; //if (durationMicro < 1000000.0) // Anything if (durationMicro == 0) // Anything { // Not yet possible to return a valid result! return -1.0; } return sGetBytesPerSecondWithMicroDuration(durationMicro, btsTotal); } private int mSocketTimeoutMilliseconds = WRITETIMEOUT; private int getSocketTimeoutMilliseconds() { return mSocketTimeoutMilliseconds; } public void setSocketTimeoutMilliseconds(int value) { mSocketTimeoutMilliseconds = value; } private boolean mbIgnoreSocketTimeout = false; public boolean getIgnoreSocketTimeout() { return mbIgnoreSocketTimeout; } public void setIgnoreSocketTimeout(boolean value) { mbIgnoreSocketTimeout = value; } }