Changeset 6462e2a for apps


Ignore:
Timestamp:
Nov 14, 2018 2:48:10 PM (20 months ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
dc343b0
Parents:
a35ad5f
Message:

MLab/NDT: Prep for connecting to wizard, fixes, cleanups

Location:
apps/routerconsole
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • apps/routerconsole/java/src/com/vuze/plugins/mlab/MLabRunner.java

    ra35ad5f r6462e2a  
    2929import java.util.List;
    3030import java.util.Map;
     31import java.util.concurrent.atomic.AtomicBoolean;
    3132
    3233import com.vuze.plugins.mlab.tools.ndt.swingemu.Tcpbw100UIWrapper;
     
    4142import net.i2p.I2PAppContext;
    4243import net.i2p.data.DataHelper;
    43 import net.i2p.router.RouterContext;
    4444import net.i2p.util.EepGet;
    4545import net.i2p.util.I2PAppThread;
     
    5252 */
    5353public class MLabRunner {
     54    // ns.measurementlab.net does not support https
     55    // use ndt_ssl for test over ssl? but Tcpbw100 doesn't support it
    5456    private static final String NS_URL = "http://ns.measurementlab.net/ndt?format=json";
    5557    private static final long NS_TIMEOUT = 20*1000;
    5658    private boolean test_active;
    5759    private final I2PAppContext _context;
    58     // null for testing
    59     private final RouterContext _rcontext;
    6060    private final Log _log;
     61    private final AtomicBoolean _running = new AtomicBoolean();
    6162    private static MLabRunner _instance;
    6263   
     
    7172    private MLabRunner(I2PAppContext ctx) {
    7273        _context = ctx;
    73         _rcontext = ctx.isRouterContext() ? (RouterContext) ctx : null;
    7474        _log = ctx.logManager().getLog(MLabRunner.class);
    7575    }
    76    
     76
     77    public boolean isRunning() {
     78       return _running.get();
     79    }
     80   
     81    /**
     82     * Non-blocking, spawns a thread and returns immediately.
     83     *
     84     * @param listener use to detect completion and get results
     85     * @return a ToolRun object which may be used to cancel the test,
     86     *         or null if there was already a test in progress.
     87     */
    7788    public ToolRun runNDT(final ToolListener listener) {
     89        if (!_running.compareAndSet(false, true)) {
     90            _log.warn("Test already running");
     91            return null;
     92        }
    7893        final ToolRun run = new ToolRunImpl();
    79         //final AESemaphore    sem = new AESemaphore( "waiter" );
    8094       
    8195        runTool(
     
    86100                    try{
    87101                        _log.warn("Starting NDT Test");
    88                         _log.warn("-----------------");
    89102                       
    90103                        new Tcpbw100UIWrapper(
     
    142155                            //               int numRetries, long minSize, long maxSize, String outputFile, OutputStream outputStream,
    143156                            //               String url, boolean allowCaching, String etag, String postData) {
    144                             // TODO why no HTTPS?
    145157                            EepGet eepget = new EepGet(_context, false, null, 0,
    146158                                                       0, 2, 1024, null, baos,
     
    161173                                _log.warn("Got response: " + DataHelper.getUTF8(b));
    162174                            // TODO use IP instead to avoid another lookup?
     175                            // or use "fqdn" in response instead of "url"
    163176                            URL url = new URL((String)map.get( "url" ));
    164177                            if (url == null) {
     
    175188                       
    176189                        if (server_host == null) {
    177                                 // fallback to old, discouraged approach
     190                            // fallback to old, discouraged approach
    178191                            server_host = "ndt.iupui.donar.measurement-lab.org";
    179192                            if (_log.shouldWarn())
     
    192205                            });
    193206                       
    194                         //sem.release();
    195                        
    196207                        test.runIt();
    197208                       
     
    203214                        }
    204215
     216                        // in integer bytes per second
    205217                        long up_bps = 0;
    206218                        try {
     
    208220                        } catch(Throwable e) {}
    209221                       
     222                        // in integer bytes per second
    210223                        long down_bps = 0;
    211224                        try {
     
    237250                        }
    238251                    } finally {
    239                         //sem.release();
    240252                        if (!completed && listener != null) {
    241253                            listener.complete( new HashMap<String, Object>());
    242254                        }
     255                        _running.set(false);
    243256                    }
    244257                }
    245258            });
    246259       
    247         //sem.reserve();
    248260        return run;
    249261    }
    250262   
    251     protected void runTool(final Runnable target) {
    252         // need something like this
    253         //ap.setEnabled( false );
    254         new I2PAppThread("toolRunner")
     263    /**
     264     * Non-blocking, spawns a thread and returns immediately.
     265     */
     266    private void runTool(final Runnable target) {
     267        new I2PAppThread("MLabRunner")
    255268        {
    256269            @Override
     
    259272                    target.run();
    260273                }finally{
    261                     //ap.setEnabled( true );
    262274                }
    263275            }
     
    265277    }
    266278   
    267     public void runTest(
    268         final Map<String,Object> args,
    269         //final IPCInterface        callback,
    270         final boolean autoApply)
    271    
    272         throws Exception
    273     {
    274         synchronized( this ){
    275             if (test_active) {
    276                 throw new Exception("Test already active");
    277             }
    278             test_active = true;
    279         }
    280     }
    281    
     279    /**
     280     * Returned from runNDT
     281     */
    282282    public interface ToolRun {
    283283        public void cancel();
     
    285285    }
    286286   
     287    /**
     288     * Returned from runNDT
     289     */
    287290    private class ToolRunImpl implements ToolRun {
    288291        private List<ToolRunListener> listeners = new ArrayList<ToolRunListener>();
     
    320323    }
    321324   
     325    /** The listener for ToolRun */
    322326    public interface ToolRunListener {
    323327        public void cancelled();
    324328    }
    325329   
     330    /** The parameter for runNDT() */
    326331    public interface ToolListener {
    327332        public void reportSummary(String str);
     
    332337    /** standalone test */
    333338    private static class TestListener implements ToolListener {
     339        private final AtomicBoolean _complete = new AtomicBoolean();
     340
    334341        public void reportSummary(String str) {
    335342            System.out.println(str);
     
    342349        public void complete(Map<String, Object> results) {
    343350            System.out.println("**************** Results: " + DataHelper.toString(results) + "***********************");
     351            _complete.set(true);
     352        }
     353
     354        public boolean isComplete() {
     355            return _complete.get();
    344356        }
    345357    }
     
    349361        I2PAppContext ctx = I2PAppContext.getGlobalContext();
    350362        MLabRunner mlab = MLabRunner.getInstance(ctx);
    351         ToolListener lsnr = new TestListener();
     363        TestListener lsnr = new TestListener();
    352364        mlab.runNDT(lsnr);
     365        try { Thread.sleep(2000); } catch (InterruptedException ie) { return; }
     366        for (int i = 0; i < 180; i++) {
     367            if (lsnr.isComplete())
     368                break;
     369            try { Thread.sleep(1000); } catch (InterruptedException ie) { break; }
     370        }
    353371    }
    354372}
  • apps/routerconsole/java/src/net/i2p/router/web/helpers/WizardHandler.java

    ra35ad5f r6462e2a  
    33import java.util.HashMap;
    44import java.util.Map;
     5import java.util.concurrent.atomic.AtomicBoolean;
     6
     7import com.vuze.plugins.mlab.MLabRunner;
    58
    69import net.i2p.router.Router;
     
    1013/**
    1114 *  The new user wizard.
     15 *  This bean has SESSION scope so the results may be retrieved.
     16 *  All necessary methods are synchronized.
    1217 *
    1318 *  @since 0.9.38
    1419 */
    1520public class WizardHandler extends FormHandler {
     21
     22    // session scope, but it's an underlying singleton
     23    private MLabRunner _mlab;
     24    // session scope
     25    private TestListener _listener;
     26
     27    @Override
     28    public void setContextId(String contextId) {
     29        super.setContextId(contextId);
     30        _mlab = MLabRunner.getInstance(_context);
     31    }
    1632   
    1733    @Override
     
    100116        return updated;
    101117    }
     118
     119    public synchronized boolean isNDTComplete() {
     120        return _listener != null && _listener.isComplete();
     121    }
     122
     123    public synchronized boolean isNDTRunning() {
     124        return _listener != null && !_listener.isComplete();
     125    }
     126
     127    /**
     128     * @return status string or null
     129     */
     130    public synchronized String getCompletionStatus() {
     131        return _listener != null ? _listener.getSummary() : null;
     132    }
     133
     134    /**
     135     * @return status string or null
     136     */
     137    public synchronized String getDetailStatus() {
     138        return _listener != null ? _listener.getDetail() : null;
     139    }
     140
     141    /**
     142     * @return bytes per second or 0
     143     */
     144    public long getUpBandwidth() {
     145        return getLongResult("up");
     146    }
     147
     148    /**
     149     * @return bytes per second or 0
     150     */
     151    public long getDownBandwidth() {
     152        return getLongResult("down");
     153    }
     154
     155    public synchronized long getLongResult(String key) {
     156        if (_listener != null) {
     157            Map<String, Object> results = _listener.getResults();
     158            if (results != null) {
     159                Long v = (Long) results.get(key);
     160                if (v != null)
     161                    return v.longValue();
     162            }
     163        }
     164        return 0;
     165    }
     166
     167    /** start the test */
     168    public synchronized void startNDT() {
     169        if (_mlab.isRunning() || _listener != null && !_listener.isComplete()) {
     170            addFormError(_t("Bandwidth test is already running"));
     171            return;
     172        }
     173        _listener = new TestListener();
     174        MLabRunner.ToolRun runner = _mlab.runNDT(_listener);
     175        if (runner != null) {
     176            addFormNotice(_t("Started bandwidth test"));
     177        } else {
     178            Map<String, Object> map = new HashMap<String, Object>(2);
     179            _listener.complete(map);
     180            addFormError(_t("Bandwidth test is already running"));
     181        }
     182    }
     183
     184    /** cancel the test */
     185    public synchronized void cancelNDT() {
     186        synchronized(WizardHandler.class) {
     187            if (!_mlab.isRunning()) {
     188                addFormError(_t("Bandwidth test was not running"));
     189                return;
     190            }
     191/****
     192TODO
     193            if (runner != null)
     194                addFormNotice(_t("Started bandwidth test"));
     195            else
     196                addFormError(_t("Bandwidth test is already running"));
     197****/
     198        }
     199    }
     200
     201    /** test results */
     202    private static class TestListener implements MLabRunner.ToolListener {
     203        private String _summary, _detail;
     204        private Map<String, Object> _results;
     205
     206        public synchronized void reportSummary(String str) {
     207            _summary = str;
     208        }
     209
     210        public synchronized void reportDetail(String str) {
     211            _detail = str;
     212        }
     213
     214        public synchronized void complete(Map<String, Object> results) {
     215            _results = results;
     216        }
     217
     218        public synchronized boolean isComplete() {
     219            return _results != null;
     220        }
     221
     222        public synchronized String getSummary() {
     223            return _summary;
     224        }
     225
     226        public synchronized String getDetail() {
     227            return _detail;
     228        }
     229
     230        public synchronized Map<String, Object> getResults() {
     231            return _results;
     232        }
     233    }
     234
    102235}
  • apps/routerconsole/java/src/net/i2p/router/web/helpers/WizardHelper.java

    ra35ad5f r6462e2a  
    1010public class WizardHelper extends HelperBase {
    1111
     12    public static final String PROP_COMPLETE = "routerconsole.welcomeWizardComplete";
     13
    1214    public void complete() {
    13         _context.router().saveConfig("routerconsole.welcomeWizardComplete", "true");
     15        _context.router().saveConfig(PROP_COMPLETE, "true");
    1416    }
    1517}
  • apps/routerconsole/jsp/index.jsp

    ra35ad5f r6462e2a  
    1313    //
    1414    response.setStatus(307);
     15    response.setHeader("Cache-Control","no-cache");
    1516    String req = request.getRequestURL().toString();
    1617    StringBuilder buf = new StringBuilder(128);
     
    2425    net.i2p.I2PAppContext ctx = net.i2p.I2PAppContext.getGlobalContext();
    2526    boolean oldHome = ctx.getBooleanProperty("routerconsole.oldHomePage");
    26     boolean wizRun = ctx.getBooleanProperty("routerconsole.welcomeWizardComplete");
     27    boolean wizRun = ctx.getBooleanProperty(net.i2p.router.web.helpers.WizardHelper.PROP_COMPLETE);
    2728    String firstVersion = ctx.getProperty("router.firstVersion");
    2829    String tgt;
     
    3031    if (oldHome) {
    3132        tgt = "console";
    32     } else if (ENABLE_WIZARD_ON_FIRST_RUN && (wizRun || firstVersion == null)) {
     33    } else if (!ENABLE_WIZARD_ON_FIRST_RUN || wizRun || firstVersion == null) {
    3334        // wizard already run
    3435        tgt = "home";
  • apps/routerconsole/jsp/welcome.jsp

    ra35ad5f r6462e2a  
    4343        // redirect to /home
    4444        response.setStatus(307);
     45        response.setHeader("Cache-Control","no-cache");
    4546        String req = request.getRequestURL().toString();
    4647        int slash = req.indexOf("/welcome");
     
    6465<script type="text/javascript">
    6566  var failMessage = "<hr><b><%=intl._t("Router is down")%><\/b>";
    66   function requestAjax1() { ajax("/welcomexhr.jsp?requestURI=<%=request.getRequestURI()%>", "xhr", "1000"); }
    67   function initAjax() { setTimeout(requestAjax1, <%=intl.getRefresh()%>000);  }
     67  function requestAjax1() { ajax("/welcomexhr.jsp", "xhr", "1000"); }
     68  function initAjax() { setTimeout(requestAjax1, "1000");  }
    6869</script>
    6970<%
     
    8485<h2><%=intl._t("New Install Wizard")%> <%=ipg%>/<%=LAST_PAGE%></h2>
    8586<div id="wizard">
    86 <jsp:useBean class="net.i2p.router.web.helpers.WizardHandler" id="formhandler" scope="request" />
     87<%--
     88    // note that for the handler we use a session scope, not a page scope,
     89    // so that we can access the NDT test results.
     90    // The MLabHelper singleton will prevent multiple simultaneous tests, even across sessions.
     91--%>
     92<jsp:useBean class="net.i2p.router.web.helpers.WizardHandler" id="formhandler" scope="session" />
    8793<%@include file="formhandler.jsi" %>
    8894<form action="" method="POST">
Note: See TracChangeset for help on using the changeset viewer.