/hg/icedtea-web: Firefox session-backup and stubs for softkiller...
jvanek at icedtea.classpath.org
jvanek at icedtea.classpath.org
Fri Nov 23 02:30:19 PST 2012
changeset a1112e2c3bc6 in /hg/icedtea-web
details: http://icedtea.classpath.org/hg/icedtea-web?cmd=changeset;node=a1112e2c3bc6
author: Jiri Vanek <jvanek at redhat.com>
date: Fri Nov 23 11:31:19 2012 +0100
Firefox session-backup and stubs for softkiller, multiple listeners,
processes handling moved to separate class.
diffstat:
ChangeLog | 31 +
tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java | 2 +-
tests/test-extensions/net/sourceforge/jnlp/ContentReader.java | 63 +-
tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java | 78 ++-
tests/test-extensions/net/sourceforge/jnlp/ProcessWrapper.java | 235 ++++++++++
tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java | 119 +---
tests/test-extensions/net/sourceforge/jnlp/ThreadedProcess.java | 10 +-
tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browser.java | 3 +-
tests/test-extensions/net/sourceforge/jnlp/browsertesting/ReactingProcess.java | 63 ++
tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Epiphany.java | 13 +-
tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Firefox.java | 38 +-
tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/LinuxBrowser.java | 19 +
tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Midory.java | 2 +-
tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/firefox/FirefoxProfilesOperator.java | 175 +++++++
14 files changed, 727 insertions(+), 124 deletions(-)
diffs (truncated from 1175 to 500 lines):
diff -r 391ea885ec4d -r a1112e2c3bc6 ChangeLog
--- a/ChangeLog Wed Nov 21 14:55:44 2012 -0500
+++ b/ChangeLog Fri Nov 23 11:31:19 2012 +0100
@@ -1,3 +1,34 @@
+2012-11-23 Jiri Vanek <jvanek at redhat.com>
+
+ Firefox session-backup and stubs for softkiller, multiple listeners,
+ processes handling moved to separate class.
+ * tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java:
+ Removed unwanted assert on termination
+ * tests/test-extensions/net/sourceforge/jnlp/ContentReader.java:
+ Added support for multiple listeners.
+ * tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java:
+ (destroyProcess()), non static wrapper around former (destroyProcess
+ (process)), introducing marks that process is being killed, added setter
+ for reactigProcess.
+ * tests/test-extensions/net/sourceforge/jnlp/ProcessWrapper.java:
+ Wrapper around former ServerAccess.executeProcess set of methods.
+ * tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java: all
+ executeProcess/Javaws/Browser are now just api compatibility methods
+ around ProcessWrapper.
+ (executeProcess) main method moved to ProcessWrapper.execute.
+ * tests/test-extensions/net/sourceforge/jnlp/ThreadedProcess.java:
+ made public and synchronized with ProcessAssasin's (destroyProcess)
+ * tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browser.java
+ is now implementing ReactingProcess
+ * tests/test-extensions/net/sourceforge/jnlp/browsertesting/ReactingProcess.java:
+ new interface for communication with main events of ThreadedProcess lifecycle.
+ * tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Firefox.java:
+ is containing singleton of FirefoxProfilesOperator (FPO) and is responding to
+ (beforeProcess) by FPO's (backupingProfiles), to (beforeKill) by calling
+ ProcessAssasin's (closeWindows), and to (afterKill) by FPO's (restoreProfiles)
+ * tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/firefox/FirefoxProfilesOperator.java:
+ New class to backup and restore firefox profiles.
+
2012-11-21 Adam Domurad <adomurad at redhat.com>
* Makefile.am: Fix new clean targets not cleaning properly
diff -r 391ea885ec4d -r a1112e2c3bc6 tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java
--- a/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java Wed Nov 21 14:55:44 2012 -0500
+++ b/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java Fri Nov 23 11:31:19 2012 +0100
@@ -131,7 +131,7 @@
try {
ProcessResult pr = server.executeBrowser("/appletAutoTests2.html", new CountingClosingListenerImpl(), new CountingClosingListenerImpl());
evaluateApplet(pr, false);
- Assert.assertTrue(pr.wasTerminated);
+ //Assert.assertTrue(pr.wasTerminated); this checks asre evil
//Assert.assertEquals((Integer) 0, pr.returnValue); due to destroy is null
} finally {
ServerAccess.PROCESS_TIMEOUT = 20 * 1000; //back to normal
diff -r 391ea885ec4d -r a1112e2c3bc6 tests/test-extensions/net/sourceforge/jnlp/ContentReader.java
--- a/tests/test-extensions/net/sourceforge/jnlp/ContentReader.java Wed Nov 21 14:55:44 2012 -0500
+++ b/tests/test-extensions/net/sourceforge/jnlp/ContentReader.java Fri Nov 23 11:31:19 2012 +0100
@@ -34,23 +34,25 @@
obligated to do so. If you do not wish to do so, delete this
exception statement from your version.
*/
-
package net.sourceforge.jnlp;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
+import java.util.ArrayList;
+import java.util.List;
/**
- * Class to read content of stdout/stderr of process, and to cooperate with its running/terminated/finished statuses.
+ * Class to read content of stdout/stderr of process, and to cooperate with its
+ * running/terminated/finished statuses.
*/
class ContentReader implements Runnable {
StringBuilder sb = new StringBuilder();
private final InputStream is;
private boolean done;
- ContentReaderListener listener;
+ final List<ContentReaderListener> listeners = new ArrayList(1);
public String getContent() {
return sb.toString();
@@ -62,15 +64,24 @@
public ContentReader(InputStream is, ContentReaderListener l) throws IOException {
this.is = is;
- this.listener = l;
+ if (l != null) {
+ this.listeners.add(l);
+ }
}
- public void setListener(ContentReaderListener listener) {
- this.listener = listener;
+ public ContentReader(InputStream is, List<ContentReaderListener> l) throws IOException {
+ this.is = is;
+ if (l != null) {
+ this.listeners.addAll(l);
+ }
}
- public ContentReaderListener getListener() {
- return listener;
+ public void addListener(ContentReaderListener listener) {
+ this.listeners.add(listener);
+ }
+
+ public List<ContentReaderListener> getListener() {
+ return listeners;
}
/**
@@ -96,8 +107,12 @@
while (true) {
int s = br.read();
if (s < 0) {
- if (line.length() > 0 && listener != null) {
- listener.lineReaded(line.toString());
+ if (line.length() > 0 && listeners != null) {
+ for (ContentReaderListener listener : listeners) {
+ if (listener != null) {
+ listener.lineReaded(line.toString());
+ }
+ }
}
break;
}
@@ -105,21 +120,31 @@
sb.append(ch);
line.append(ch);
if (ch == '\n') {
- if (listener != null) {
- listener.lineReaded(line.toString());
+ if (listeners != null) {
+ for (ContentReaderListener listener : listeners) {
+ if (listener != null) {
+ listener.lineReaded(line.toString());
+ }
+ }
}
line = new StringBuilder();
}
- if (listener != null) {
- listener.charReaded(ch);
+ if (listeners != null) {
+ for (ContentReaderListener listener : listeners) {
+ if (listener != null) {
+ listener.charReaded(ch);
+ }
+ }
}
}
- //do not want to bother output with terminations
- //mostly compaling when assassin kill the process about StreamClosed
- //do not want to bother output with terminations
- //mostly compaling when assassin kill the process about StreamClosed
- } catch (Exception ex) {
+ } catch (NullPointerException ex) {
+ ex.printStackTrace();
+ }
+ //do not want to bother output with terminations
+ //mostly compaling when assassin kill the process about StreamClosed
+ catch (Exception ex) {
// logException(ex);
+ //ex.printStackTrace();
} finally {
try {
is.close();
diff -r 391ea885ec4d -r a1112e2c3bc6 tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java
--- a/tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java Wed Nov 21 14:55:44 2012 -0500
+++ b/tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java Fri Nov 23 11:31:19 2012 +0100
@@ -39,24 +39,32 @@
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
+import net.sourceforge.jnlp.browsertesting.ReactingProcess;
/**
- * class which timeout any ThreadedProcess. This killing of 'thread with process' replaced not working process.destroy().
+ * class which timeout any ThreadedProcess. This killing of 'thread with
+ * process' replaced not working process.destroy().
*/
-class ProcessAssasin extends Thread {
+public class ProcessAssasin extends Thread {
long timeout;
private final ThreadedProcess p;
//false == is disabled:(
private boolean canRun = true;
private boolean wasTerminated = false;
+ //signifies that assasin have been summoned
+ private volatile boolean killing = false;
+ //signifies that assasin have done its job
+ private volatile boolean killed = false;
/**
- * if this is true, then process is not destroyed after timeout, but just left to its own destiny.
- * Its stdout/err is no longer recorded, and it is leaking system resources until it dies by itself
- * The contorl is returned to main thread with all informations recorded untill now.
- * You will be able to listen to std out from listeners still
+ * if this is true, then process is not destroyed after timeout, but just
+ * left to its own destiny. Its stdout/err is no longer recorded, and it is
+ * leaking system resources until it dies by itself The contorl is returned
+ * to main thread with all informations recorded untill now. You will be
+ * able to listen to std out from listeners still
*/
private boolean skipInstedOfDesroy = false;
+ private ReactingProcess reactingProcess;
public ProcessAssasin(ThreadedProcess p, long timeout) {
this.p = (p);
@@ -123,7 +131,7 @@
if (p.getP() != null) {
try {
if (!skipInstedOfDesroy) {
- destroyProcess(p);
+ destroyProcess();
}
} catch (Throwable ex) {
if (p.deadlyException == null) {
@@ -165,12 +173,34 @@
}
}
- public static void destroyProcess(ThreadedProcess pp) {
+ public void destroyProcess() {
+ try {
+ killing = true;
+ destroyProcess(p, reactingProcess);
+ } finally {
+ killed = true;
+ }
+ }
+
+ public boolean haveKilled() {
+ return killed;
+ }
+
+ public boolean isKilling() {
+ return killing;
+ }
+
+
+
+ public static void destroyProcess(ThreadedProcess pp, ReactingProcess reactingProcess) {
Process p = pp.getP();
try {
Field f = p.getClass().getDeclaredField("pid");
f.setAccessible(true);
String pid = (f.get(p)).toString();
+ if (reactingProcess != null) {
+ reactingProcess.beforeKill(pid);
+ };
sigInt(pid);
//sigTerm(pid);
//sigKill(pid);
@@ -178,6 +208,9 @@
ServerAccess.logException(ex);
} finally {
p.destroy();
+ if (reactingProcess != null) {
+ reactingProcess.afterKill("");
+ };
}
}
@@ -193,7 +226,7 @@
kill(pid, "SIGTERM");
}
- public static void kill(String pid,String signal) throws InterruptedException, Exception {
+ public static void kill(String pid, String signal) throws InterruptedException, Exception {
List<String> ll = new ArrayList<String>(4);
ll.add("kill");
ll.add("-s");
@@ -203,4 +236,31 @@
//before affected application close
Thread.sleep(1000);
}
+
+ void setReactingProcess(ReactingProcess reactingProcess) {
+ this.reactingProcess = reactingProcess;
+ }
+
+ public static void closeWindow(String pid) throws Exception {
+ List<String> ll = new ArrayList<String>(2);
+ ll.add(ServerAccess.getInstance().getDir().getParent() + "/softkiller");
+ ll.add(pid);
+ ServerAccess.executeProcess(ll); //sync, but acctually release
+ //before affected application "close"
+ Thread.sleep(100);
+
+ }
+
+ public static void closeWindows(String s) throws Exception {
+ closeWindows(s, 10);
+ }
+
+ public static void closeWindows(String s, int count) throws Exception {
+ //each close closes just one tab...
+ for (int i = 0; i < count; i++) {
+ ProcessAssasin.closeWindow(s);
+ }
+ }
+
+
}
diff -r 391ea885ec4d -r a1112e2c3bc6 tests/test-extensions/net/sourceforge/jnlp/ProcessWrapper.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-extensions/net/sourceforge/jnlp/ProcessWrapper.java Fri Nov 23 11:31:19 2012 +0100
@@ -0,0 +1,235 @@
+/* ProcessWrapper.java
+Copyright (C) 2011,2012 Red Hat, Inc.
+
+This file is part of IcedTea.
+
+IcedTea 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.
+
+IcedTea 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 IcedTea; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version.
+ */
+
+package net.sourceforge.jnlp;
+
+import java.io.File;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import net.sourceforge.jnlp.browsertesting.ReactingProcess;
+import org.junit.Assert;
+
+
+
+/**
+ * This class wraps execution of ThreadedProcess.
+ * Add listeners and allows another setters, eg of ReactingProcess
+ *
+ */
+public class ProcessWrapper {
+
+ private List<String> args;
+ private File dir;
+ private final List<ContentReaderListener> stdoutl = new ArrayList(1);
+ private final List<ContentReaderListener> stderrl = new ArrayList(1);
+ private String[] vars;
+ private ReactingProcess reactingProcess;
+
+ public ProcessWrapper() {
+ }
+
+ public ProcessWrapper(String toBeExecuted, List<String> otherargs, URL u, ContentReaderListener stdoutl, ContentReaderListener stderrl, String[] vars) throws Exception {
+ Assert.assertNotNull(u);
+ Assert.assertNotNull(toBeExecuted);
+ Assert.assertTrue(toBeExecuted.trim().length() > 1);
+ if (otherargs == null) {
+ otherargs = new ArrayList(1);
+ }
+ List<String> urledArgs = new ArrayList(otherargs);
+ urledArgs.add(0, toBeExecuted);
+ urledArgs.add(u.toString());
+ this.args = urledArgs;
+ this.addStdOutListener(stdoutl);
+ this.addStdErrListener(stderrl);
+ this.vars=vars;
+
+ }
+
+ ProcessWrapper(final List<String> args, File dir, ContentReaderListener stdoutl, ContentReaderListener stderrl, String[] vars) {
+ this.args = args;
+ this.dir = dir;
+ this.addStdOutListener(stdoutl);
+ this.addStdErrListener(stderrl);
+ this.vars = vars;
+ }
+
+ public final void addStdOutListener(ContentReaderListener l) {
+ if (l == null) {
+ return;
+ }
+ stdoutl.add(l);
+
+ }
+
+ public final void addStdErrListener(ContentReaderListener l) {
+ if (l == null) {
+ return;
+ }
+ stderrl.add(l);
+
+ }
+
+ /**
+ * @return the args
+ */
+ public List<String> getArgs() {
+ return args;
+ }
+
+ /**
+ * @param args the args to set
+ */
+ public void setArgs(List<String> args) {
+ this.args = args;
+ }
+
+ /**
+ * @return the dir
+ */
+ public File getDir() {
+ return dir;
+ }
+
+ /**
+ * @param dir the dir to set
+ */
+ public void setDir(File dir) {
+ this.dir = dir;
+ }
+
+ /**
+ * @return the stdoutl
+ */
+ public List<ContentReaderListener> getStdoutListeners() {
+ return stdoutl;
+ }
+
+ /**
+ * @return the stderrl
+ */
+ public List<ContentReaderListener> getStderrListeners() {
+ return stderrl;
+ }
+
+ /**
+ * @return the vars
+ */
+ public String[] getVars() {
+ return vars;
+ }
+
+ /**
+ * @param vars the vars to set
+ */
+ public void setVars(String[] vars) {
+ this.vars = vars;
+ }
+
+ public ServerAccess.ProcessResult execute() throws Exception {
+ if (reactingProcess !=null ){
+ reactingProcess.beforeProcess("");
+ };
+ ThreadedProcess t = new ThreadedProcess(args, dir, vars);
+ if (ServerAccess.PROCESS_LOG) {
+ String connectionMesaage = createConnectionMessage(t);
+ ServerAccess.log(connectionMesaage, true, true);
+ }
+ ProcessAssasin pa = new ProcessAssasin(t, ServerAccess.PROCESS_TIMEOUT);
+ t.setAssasin(pa);
+ pa.setReactingProcess(reactingProcess);
+ setUpClosingListener(stdoutl, pa, t);
+ setUpClosingListener(stderrl, pa, t);
+ pa.start();
+ t.start();
+ while (t.getP() == null && t.deadlyException == null) {
+ Thread.sleep(100);
+ }
+ if (t.deadlyException != null) {
+ pa.setCanRun(false);
+ return new ServerAccess.ProcessResult("", "", null, true, Integer.MIN_VALUE, t.deadlyException);
+ }
+ ContentReader crs = new ContentReader(t.getP().getInputStream(), stdoutl);
+ ContentReader cre = new ContentReader(t.getP().getErrorStream(), stderrl);
+
+ OutputStream out = t.getP().getOutputStream();
More information about the distro-pkg-dev
mailing list