@Override
public void mousePressed(final MouseEvent e) {
Performance.gc(3);
repaint();
final Runtime rt = Runtime.getRuntime();
final long max = rt.maxMemory();
final long total = rt.totalMemory();
final long used = total - rt.freeMemory();
final String inf =
TOTAL_MEM_C
+ Performance.format(max, true)
+ NL
+ RESERVED_MEM_C
+ Performance.format(total, true)
+ NL
+ MEMUSED_C
+ Performance.format(used, true)
+ NL
+ NL
+ H_USED_MEM;
BaseXDialog.info(gui, inf);
}
/**
* Stops the server.
*
* @param port server port
* @param eport event port
* @throws IOException I/O exception
*/
public static void stop(final int port, final int eport) throws IOException {
final File stop = stopFile(port);
try {
stop.createNewFile();
new Socket(LOCALHOST, eport).close();
new Socket(LOCALHOST, port).close();
// check if server was really stopped
while (ping(LOCALHOST, port)) Performance.sleep(50);
Performance.sleep(50);
} catch (final IOException ex) {
stop.delete();
throw ex;
}
}
/**
* Runs the command without permission, data and concurrency checks.
*
* @param ctx database context
* @param os output stream
* @return result of check
*/
public boolean run(final Context ctx, final OutputStream os) {
perf = new Performance();
context = ctx;
prop = ctx.prop;
mprop = ctx.mprop;
out = PrintOutput.get(os);
try {
return run();
} catch (final ProgressException ex) {
// process was interrupted by the user or server
abort();
return error(INTERRUPTED);
} catch (final Throwable ex) {
// unexpected error
Performance.gc(2);
abort();
if (ex instanceof OutOfMemoryError) {
Util.debug(ex);
return error(OUT_OF_MEM + (createWrite() ? H_OUT_OF_MEM : ""));
}
return error(Util.bug(ex) + NL + info.toString());
} finally {
// flushes the output
try {
if (out != null) out.flush();
} catch (final IOException ignored) {
}
}
}
/** Notifies all views of a data reference change. */
public void init() {
final Data data = initHistory(gui.context);
if (data != null) {
// if a large database is opened, the user is asked if complex
/// visualizations should be closed first
final long size = data.meta.dbsize();
boolean open = false;
for (final View v : view) open |= v.visible() && v.db();
if (open
&& size > LARGEDB
&& BaseXDialog.confirm(gui, Util.info(H_LARGE_DB, Performance.format(size)))) {
for (final View v : view) if (v.visible() && v.db()) v.visible(false);
}
} else {
// database closed: close open dialogs
for (final Window w : gui.getOwnedWindows()) {
if (w.isVisible() && w instanceof BaseXDialog) ((BaseXDialog) w).cancel();
}
}
gui.context.focused = -1;
for (final View v : view) v.refreshInit();
gui.layoutViews();
gui.setTitle(data != null ? data.meta.name : null);
}
/**
* Test concurrent reader and writer (GH-458).
*
* <p><b>Test case:</b>
*
* <ol>
* <li/>start a long running reader;
* <li/>try to start a writer: it should time out;
* <li/>stop the reader;
* <li/>start the writer again: it should succeed.
* </ol>
*
* @throws Exception error during request execution
*/
@Test
@Ignore("There is no way to stop a query on the server!")
public void testReaderWriter() throws Exception {
final String readerQuery = "?query=(1%20to%20100000000000000)%5b.=1%5d";
final String writerQuery = "/test.xml";
final byte[] content = Token.token("<a/>");
final Get readerAction = new Get(readerQuery);
final Put writerAction = new Put(writerQuery, content);
final ExecutorService exec = Executors.newFixedThreadPool(2);
// start reader
exec.submit(readerAction);
Performance.sleep(TIMEOUT); // delay in order to be sure that the reader has started
// start writer
Future<HTTPResponse> writer = exec.submit(writerAction);
try {
final HTTPResponse result = writer.get(TIMEOUT, TimeUnit.MILLISECONDS);
if (result.status.isSuccess()) fail("Database modified while a reader is running");
throw new Exception(result.toString());
} catch (final TimeoutException e) {
// writer is blocked by the reader: stop it
writerAction.stop = true;
}
// stop reader
readerAction.stop = true;
// start the writer again
writer = exec.submit(writerAction);
assertEquals(HTTPCode.CREATED, writer.get().status);
}
/**
* Writes a log message.
*
* @param str strings to be written
* @param time add performance info
*/
public void log(final boolean time, final Object... str) {
final Object[] obj = new Object[str.length + (time ? 2 : 1)];
obj[0] = remote();
System.arraycopy(str, 0, obj, 1, str.length);
if (time) obj[obj.length - 1] = perf.toString();
context.log.write(obj);
}
/** Drops users. */
@Test
public void dropUsers() {
no(new DropUser(NAME), testSession);
no(new DropUser(NAME), adminSession);
ok(new Exit(), testSession);
// give the server some time to close the client session
Performance.sleep(50);
ok(new DropUser(NAME), adminSession);
}
/**
* Extracts and indexes words from the specified data reference.
*
* @throws IOException I/O Exception
*/
final void index() throws IOException {
// delete old index
abort();
final Performance perf = Prop.debug ? new Performance() : null;
Util.debug(det());
for (pre = 0; pre < size; ++pre) {
if ((pre & 0xFFFF) == 0) check();
final int k = data.kind(pre);
if (k != Data.TEXT) {
if (scm == 1 && k == Data.DOC) unit.add(pre);
continue;
}
if (scm == 2) unit.add(pre);
pos = -1;
final StopWords sw = lex.ftOpt().sw;
lex.init(data.text(pre, true));
while (lex.hasNext()) {
final byte[] tok = lex.nextToken();
++pos;
// skip too long and stopword tokens
if (tok.length <= data.meta.maxlen && (sw.size() == 0 || !sw.contains(tok))) {
// check if main memory is exhausted
if ((ntok++ & 0xFFF) == 0 && scm == 0 && memFull()) {
// currently no frequency support for tf/idf based scoring
writeIndex(csize++);
Performance.gc(2);
}
index(tok);
}
}
}
// calculate term frequencies
if (scm > 0) {
maxfreq = new int[unit.size() + 1];
ntoken = new int[nrTokens()];
token = 0;
calcFreq();
}
// write tokens
token = 0;
write();
// set meta data
if (scm > 0) {
data.meta.maxscore = max;
data.meta.minscore = min;
}
data.meta.ftxtindex = true;
Util.memory(perf);
}
@Override
public void run() {
while (text != null) {
flashing ^= true;
panel.repaint();
Performance.sleep(500);
}
flashing = false;
panel.repaint();
}
/**
* Parses the query.
*
* @param p performance
* @throws QueryException query exception
*/
private void parse(final Performance p) throws QueryException {
qp.http(http);
for (final Entry<String, String[]> entry : vars.entrySet()) {
final String name = entry.getKey();
final String[] value = entry.getValue();
if (name == null) qp.context(value[0], value[1]);
else qp.bind(name, value[0], value[1]);
}
qp.parse();
if (p != null) info.parsing += p.time();
}
@Override
public synchronized byte[] info(final MainOptions options) {
final TokenBuilder tb = new TokenBuilder();
final long l = inX.length() + inY.length() + inZ.length();
tb.add(LI_NAMES).add(data.meta.ftinclude).add(NL);
tb.add(LI_SIZE + Performance.format(l, true) + NL);
final IndexStats stats = new IndexStats(options.get(MainOptions.MAXSTAT));
addOccs(stats);
stats.print(tb);
return tb.finish();
}
/** Clean up method. */
@After
public void cleanUp() {
try {
testSession.close();
adminSession.execute(new DropDB(RENAMED));
adminSession.execute(new DropDB(NAME));
adminSession.close();
// give the server some time to clean up the sessions before next test
Performance.sleep(100);
} catch (final Exception ex) {
fail(Util.message(ex));
}
}
@Override
public void run() {
try {
for (int i = 0; i < runs; ++i) {
Performance.sleep((long) (50 * RND.nextDouble()));
// Return nth text of the database
final int n = RND.nextInt() % MAX + 1;
final String qu = Util.info(QUERY, n);
new XQuery(qu).execute(context);
}
} catch (final BaseXException ex) {
ex.printStackTrace();
}
}
/**
* Starts the database server in a separate process.
*
* @param port server port
* @param args command-line arguments
* @throws BaseXException database exception
*/
public static void start(final int port, final String... args) throws BaseXException {
// check if server is already running (needs some time)
if (ping(LOCALHOST, port)) throw new BaseXException(SRV_RUNNING);
Util.start(BaseXServer.class, args);
// try to connect to the new server instance
for (int c = 0; c < 10; ++c) {
if (ping(LOCALHOST, port)) return;
Performance.sleep(100);
}
throw new BaseXException(CONNECTION_ERROR);
}
@Override
public DiskData build() throws IOException {
meta.assign(parser);
meta.dirty = true;
// calculate optimized output buffer sizes to reduce disk fragmentation
final Runtime rt = Runtime.getRuntime();
final long max = Math.min(1 << 22, rt.maxMemory() - rt.freeMemory() >> 2);
int bs = (int) Math.min(meta.filesize, max);
bs = Math.max(IO.BLOCKSIZE, bs - bs % IO.BLOCKSIZE);
// drop old database (if available) and create new one
DropDB.drop(dbname, sopts);
sopts.dbpath(dbname).md();
elemNames = new Names(meta);
attrNames = new Names(meta);
try {
tout = new DataOutput(new TableOutput(meta, DATATBL));
xout = new DataOutput(meta.dbfile(DATATXT), bs);
vout = new DataOutput(meta.dbfile(DATAATV), bs);
sout = new DataOutput(meta.dbfile(DATATMP), bs);
final Performance perf = Prop.debug ? new Performance() : null;
Util.debug(tit() + DOTS);
parse();
if (Prop.debug) Util.errln(" " + perf + " (" + Performance.getMemory() + ')');
} catch (final IOException ex) {
try {
close();
} catch (final IOException ignored) {
}
throw ex;
}
close();
// copy temporary values into database table
try (final DataInput in = new DataInput(meta.dbfile(DATATMP))) {
final TableAccess ta = new TableDiskAccess(meta, true);
for (; spos < ssize; ++spos) ta.write4(in.readNum(), 8, in.readNum());
ta.close();
}
meta.dbfile(DATATMP).delete();
// return database instance
return new DiskData(meta, elemNames, attrNames, path, ns);
}
@Override
public void run() {
try {
// Perform some queries
for (int i = 0; i < runs; ++i) {
Performance.sleep((long) (50 * RND.nextDouble()));
// Return nth text of the database
final int n = RND.nextInt() % MAX + 1;
final String qu = Util.info(QUERY, n);
session.execute("xquery " + qu);
}
session.close();
} catch (final Exception ex) {
ex.printStackTrace();
}
}
/**
* Authenticate the user and returns a new client {@link Context} instance.
*
* @return client context
* @throws LoginException login exception
*/
public Context authenticate() throws LoginException {
final byte[] address = token(req.getRemoteAddr());
try {
if (user == null || user.isEmpty() || pass == null || pass.isEmpty())
throw new LoginException(NOPASSWD);
final Context ctx = new Context(context(), null);
ctx.user = ctx.users.get(user);
if (ctx.user == null || !ctx.user.password.equals(md5(pass))) throw new LoginException();
context.blocker.remove(address);
return ctx;
} catch (final LoginException ex) {
// delay users with wrong passwords
for (int d = context.blocker.delay(address); d > 0; d--) Performance.sleep(100);
throw ex;
}
}
/**
* Test 2 concurrent readers (GH-458).
*
* <p><b>Test case:</b>
*
* <ol>
* <li/>start a long running reader;
* <li/>start a fast reader: it should succeed.
* </ol>
*
* @throws Exception error during request execution
*/
@Test
public void testMultipleReaders() throws Exception {
final String number = "63177";
final String slowQuery = "?query=(1%20to%20100000000000000)%5b.=1%5d";
final String fastQuery = "?query=" + number;
final Get slowAction = new Get(slowQuery);
final Get fastAction = new Get(fastQuery);
final ExecutorService exec = Executors.newFixedThreadPool(2);
exec.submit(slowAction);
Performance.sleep(TIMEOUT); // delay in order to be sure that the reader has started
final Future<HTTPResponse> fast = exec.submit(fastAction);
try {
final HTTPResponse result = fast.get(TIMEOUT, TimeUnit.MILLISECONDS);
assertEquals(HTTPCode.OK, result.status);
assertEquals(number, result.data);
} finally {
slowAction.stop = true;
}
}
@Override
public void paintComponent(final Graphics g) {
super.paintComponent(g);
final Runtime rt = Runtime.getRuntime();
final long max = rt.maxMemory();
final long total = rt.totalMemory();
final long used = total - rt.freeMemory();
final int ww = getWidth();
final int hh = getHeight();
// draw memory box
g.setColor(Color.white);
g.fillRect(0, 0, ww - 3, hh - 3);
g.setColor(GRAY);
g.drawLine(0, 0, ww - 4, 0);
g.drawLine(0, 0, 0, hh - 4);
g.drawLine(ww - 3, 0, ww - 3, hh - 3);
g.drawLine(0, hh - 3, ww - 3, hh - 3);
// show total memory usage
g.setColor(color1);
g.fillRect(2, 2, Math.max(1, (int) (total * (ww - 6) / max)), hh - 6);
// show current memory usage
final boolean full = used * 6 / 5 > max;
g.setColor(full ? colormark4 : color3);
g.fillRect(2, 2, Math.max(1, (int) (used * (ww - 6) / max)), hh - 6);
// print current memory usage
final FontMetrics fm = g.getFontMetrics();
final String mem = Performance.format(used, true);
final int fw = (ww - fm.stringWidth(mem)) / 2;
final int h = fm.getHeight() - 3;
g.setColor(full ? colormark3 : DGRAY);
g.drawString(mem, fw, h);
}
/** Exits the session. */
public synchronized void quit() {
running = false;
if (log != null) log.write(this, "LOGOUT " + context.user.name, OK);
// wait until running command was stopped
if (command != null) {
command.stop();
while (command != null) Performance.sleep(50);
}
context.delete(this);
try {
new Close().execute(context);
socket.close();
if (events) {
esocket.close();
// remove this session from all events in pool
for (final Sessions s : context.events.values()) s.remove(this);
}
} catch (final Exception ex) {
if (log != null) log.write(ex.getMessage());
Util.stack(ex);
}
}
/**
* Parses the specified test case.
*
* @param root root node
* @throws Exception exception
* @return true if the query, specified by {@link #single}, was evaluated
*/
private boolean parse(final Nodes root) throws Exception {
final String pth = text("@FilePath", root);
final String outname = text("@name", root);
if (single != null && !outname.startsWith(single)) return true;
final Performance perf = new Performance();
if (verbose) Util.out("- " + outname);
boolean inspect = false;
boolean correct = true;
final Nodes nodes = states(root);
for (int n = 0; n < nodes.size(); ++n) {
final Nodes state = new Nodes(nodes.list[n], nodes.data);
final String inname = text("*:query/@name", state);
context.query = new IOFile(queries + pth + inname + IO.XQSUFFIX);
final String in = read(context.query);
String er = null;
ItemCache iter = null;
boolean doc = true;
final Nodes cont = nodes("*:contextItem", state);
Nodes curr = null;
if (cont.size() != 0) {
final Data d = Check.check(context, srcs.get(string(data.atom(cont.list[0]))));
curr = new Nodes(d.doc(), d);
curr.root = true;
}
context.prop.set(Prop.QUERYINFO, compile);
final QueryProcessor xq = new QueryProcessor(in, curr, context);
context.prop.set(Prop.QUERYINFO, false);
// limit result sizes to 1MB
final ArrayOutput ao = new ArrayOutput();
final TokenBuilder files = new TokenBuilder();
try {
files.add(
file(nodes("*:input-file", state), nodes("*:input-file/@variable", state), xq, n == 0));
files.add(file(nodes("*:defaultCollection", state), null, xq, n == 0));
var(nodes("*:input-URI", state), nodes("*:input-URI/@variable", state), xq);
eval(nodes("*:input-query/@name", state), nodes("*:input-query/@variable", state), pth, xq);
parse(xq, state);
for (final int p : nodes("*:module", root).list) {
final String uri = text("@namespace", new Nodes(p, data));
final String file = mods.get(string(data.atom(p))) + IO.XQSUFFIX;
xq.module(file, uri);
}
// evaluate and serialize query
final SerializerProp sp = new SerializerProp();
sp.set(SerializerProp.S_INDENT, context.prop.is(Prop.CHOP) ? DataText.YES : DataText.NO);
final XMLSerializer xml = new XMLSerializer(ao, sp);
iter = xq.value().cache();
for (Item it; (it = iter.next()) != null; ) {
doc &= it.type == NodeType.DOC;
it.serialize(xml);
}
xml.close();
} catch (final Exception ex) {
if (!(ex instanceof QueryException || ex instanceof IOException)) {
System.err.println("\n*** " + outname + " ***");
System.err.println(in + "\n");
ex.printStackTrace();
}
er = ex.getMessage();
if (er.startsWith(STOPPED)) er = er.substring(er.indexOf('\n') + 1);
if (er.startsWith("[")) er = er.replaceAll("\\[(.*?)\\] (.*)", "$1 $2");
// unexpected error - dump stack trace
}
// print compilation steps
if (compile) {
Util.errln("---------------------------------------------------------");
Util.err(xq.info());
Util.errln(in);
}
final Nodes expOut = nodes("*:output-file/text()", state);
final TokenList result = new TokenList();
for (int o = 0; o < expOut.size(); ++o) {
final String resFile = string(data.atom(expOut.list[o]));
final IOFile exp = new IOFile(expected + pth + resFile);
result.add(read(exp));
}
final Nodes cmpFiles = nodes("*:output-file/@compare", state);
boolean xml = false;
boolean frag = false;
boolean ignore = false;
for (int o = 0; o < cmpFiles.size(); ++o) {
final byte[] type = data.atom(cmpFiles.list[o]);
xml |= eq(type, XML);
frag |= eq(type, FRAGMENT);
ignore |= eq(type, IGNORE);
}
String expError = text("*:expected-error/text()", state);
final StringBuilder log = new StringBuilder(pth + inname + IO.XQSUFFIX);
if (files.size() != 0) {
log.append(" [");
log.append(files);
log.append("]");
}
log.append(NL);
/** Remove comments. */
log.append(norm(in));
log.append(NL);
final String logStr = log.toString();
// skip queries with variable results
final boolean print = currTime || !logStr.contains("current-");
boolean correctError = false;
if (er != null && (expOut.size() == 0 || !expError.isEmpty())) {
expError = error(pth + outname, expError);
final String code = er.substring(0, Math.min(8, er.length()));
for (final String e : SLASH.split(expError)) {
if (code.equals(e)) {
correctError = true;
break;
}
}
}
if (correctError) {
if (print) {
logOK.append(logStr);
logOK.append("[Right] ");
logOK.append(norm(er));
logOK.append(NL);
logOK.append(NL);
addLog(pth, outname + ".log", er);
}
++ok;
} else if (er == null) {
int s = -1;
final int rs = result.size();
while (!ignore && ++s < rs) {
inspect |= s < cmpFiles.list.length && eq(data.atom(cmpFiles.list[s]), INSPECT);
final byte[] res = result.get(s), actual = ao.toArray();
if (res.length == ao.size() && eq(res, actual)) break;
if (xml || frag) {
iter.reset();
try {
final ItemCache ic =
toIter(string(res).replaceAll("^<\\?xml.*?\\?>", "").trim(), frag);
if (FNSimple.deep(null, iter, ic)) break;
ic.reset();
final ItemCache ia = toIter(string(actual), frag);
if (FNSimple.deep(null, ia, ic)) break;
} catch (final Throwable ex) {
System.err.println("\n" + outname + ":");
ex.printStackTrace();
}
}
}
if ((rs > 0 || !expError.isEmpty()) && s == rs && !inspect) {
if (print) {
if (expOut.size() == 0) result.add(error(pth + outname, expError));
logErr.append(logStr);
logErr.append("[" + testid + " ] ");
logErr.append(norm(string(result.get(0))));
logErr.append(NL);
logErr.append("[Wrong] ");
logErr.append(norm(ao.toString()));
logErr.append(NL);
logErr.append(NL);
addLog(pth, outname + (xml ? IO.XMLSUFFIX : ".txt"), ao.toString());
}
correct = false;
++err;
} else {
if (print) {
logOK.append(logStr);
logOK.append("[Right] ");
logOK.append(norm(ao.toString()));
logOK.append(NL);
logOK.append(NL);
addLog(pth, outname + (xml ? IO.XMLSUFFIX : ".txt"), ao.toString());
}
++ok;
}
} else {
if (expOut.size() == 0 || !expError.isEmpty()) {
if (print) {
logOK2.append(logStr);
logOK2.append("[" + testid + " ] ");
logOK2.append(norm(expError));
logOK2.append(NL);
logOK2.append("[Rght?] ");
logOK2.append(norm(er));
logOK2.append(NL);
logOK2.append(NL);
addLog(pth, outname + ".log", er);
}
++ok2;
} else {
if (print) {
logErr2.append(logStr);
logErr2.append("[" + testid + " ] ");
logErr2.append(norm(string(result.get(0))));
logErr2.append(NL);
logErr2.append("[Wrong] ");
logErr2.append(norm(er));
logErr2.append(NL);
logErr2.append(NL);
addLog(pth, outname + ".log", er);
}
correct = false;
++err2;
}
}
if (curr != null) Close.close(curr.data, context);
xq.close();
}
if (reporting) {
logReport.append(" <test-case name=\"");
logReport.append(outname);
logReport.append("\" result='");
logReport.append(correct ? "pass" : "fail");
if (inspect) logReport.append("' todo='inspect");
logReport.append("'/>");
logReport.append(NL);
}
// print verbose/timing information
final long nano = perf.getTime();
final boolean slow = nano / 1000000 > timer;
if (verbose) {
if (slow) Util.out(": " + Performance.getTimer(nano, 1));
Util.outln();
} else if (slow) {
Util.out(NL + "- " + outname + ": " + Performance.getTimer(nano, 1));
}
return single == null || !outname.equals(single);
}
/**
* Runs the test suite.
*
* @param args command-line arguments
* @throws Exception exception
*/
void run(final String[] args) throws Exception {
final Args arg =
new Args(
args,
this,
" Test Suite [options] [pat]"
+ NL
+ " [pat] perform only tests with the specified pattern"
+ NL
+ " -c print compilation steps"
+ NL
+ " -h show this help"
+ NL
+ " -m minimum conformance"
+ NL
+ " -g <test-group> test group to test"
+ NL
+ " -C run tests depending on current time"
+ NL
+ " -p change path"
+ NL
+ " -r create report"
+ NL
+ " -t[ms] list slowest queries"
+ NL
+ " -v verbose output");
while (arg.more()) {
if (arg.dash()) {
final char c = arg.next();
if (c == 'r') {
reporting = true;
currTime = true;
} else if (c == 'C') {
currTime = true;
} else if (c == 'c') {
compile = true;
} else if (c == 'm') {
minimum = true;
} else if (c == 'g') {
group = arg.string();
} else if (c == 'p') {
path = arg.string() + "/";
} else if (c == 't') {
timer = arg.num();
} else if (c == 'v') {
verbose = true;
} else {
arg.check(false);
}
} else {
single = arg.string();
maxout = Integer.MAX_VALUE;
}
}
if (!arg.finish()) return;
queries = path + "Queries/XQuery/";
expected = path + "ExpectedTestResults/";
results = path + "ReportingResults/Results/";
report = path + "ReportingResults/";
sources = path + "TestSources/";
final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
final String dat = sdf.format(Calendar.getInstance().getTime());
final Performance perf = new Performance();
context.prop.set(Prop.CHOP, false);
// new Check(path + input).execute(context);
data = CreateDB.xml(new IOFile(path + input), context);
final Nodes root = new Nodes(0, data);
Util.outln(NL + Util.name(this) + " Test Suite " + text("/*:test-suite/@version", root));
Util.outln(NL + "Caching Sources...");
for (final int s : nodes("//*:source", root).list) {
final Nodes srcRoot = new Nodes(s, data);
final String val = (path + text("@FileName", srcRoot)).replace('\\', '/');
srcs.put(text("@ID", srcRoot), val);
}
Util.outln("Caching Modules...");
for (final int s : nodes("//*:module", root).list) {
final Nodes srcRoot = new Nodes(s, data);
final String val = (path + text("@FileName", srcRoot)).replace('\\', '/');
mods.put(text("@ID", srcRoot), val);
}
Util.outln("Caching Collections...");
for (final int c : nodes("//*:collection", root).list) {
final Nodes nodes = new Nodes(c, data);
final String cname = text("@ID", nodes);
final TokenList dl = new TokenList();
final Nodes doc = nodes("*:input-document", nodes);
for (int d = 0; d < doc.size(); ++d) {
dl.add(token(sources + string(data.atom(doc.list[d])) + IO.XMLSUFFIX));
}
colls.put(cname, dl.toArray());
}
init(root);
if (reporting) {
Util.outln("Delete old results...");
delete(new File[] {new File(results)});
}
if (verbose) Util.outln();
final Nodes nodes =
minimum
? nodes("//*:test-group[starts-with(@name, 'Minim')]//*:test-case", root)
: group != null
? nodes("//*:test-group[@name eq '" + group + "']//*:test-case", root)
: nodes("//*:test-case", root);
long total = nodes.size();
Util.out("Parsing " + total + " Queries");
for (int t = 0; t < total; ++t) {
if (!parse(new Nodes(nodes.list[t], data))) break;
if (!verbose && t % 500 == 0) Util.out(".");
}
Util.outln();
total = ok + ok2 + err + err2;
final String time = perf.getTimer();
Util.outln("Writing log file..." + NL);
BufferedWriter bw =
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path + pathlog), UTF8));
bw.write("TEST RESULTS ==================================================");
bw.write(NL + NL + "Total #Queries: " + total + NL);
bw.write("Correct / Empty Results: " + ok + " / " + ok2 + NL);
bw.write("Conformance (w/Empty Results): ");
bw.write(pc(ok, total) + " / " + pc(ok + ok2, total) + NL);
bw.write("Wrong Results / Errors: " + err + " / " + err2 + NL);
bw.write("WRONG =========================================================");
bw.write(NL + NL + logErr + NL);
bw.write("WRONG (ERRORS) ================================================");
bw.write(NL + NL + logErr2 + NL);
bw.write("CORRECT? (EMPTY) ==============================================");
bw.write(NL + NL + logOK2 + NL);
bw.write("CORRECT =======================================================");
bw.write(NL + NL + logOK + NL);
bw.write("===============================================================");
bw.close();
bw = new BufferedWriter(new FileWriter(path + pathhis, true));
bw.write(dat + "\t" + ok + "\t" + ok2 + "\t" + err + "\t" + err2 + NL);
bw.close();
if (reporting) {
bw =
new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(report + NAME + IO.XMLSUFFIX), UTF8));
write(bw, report + NAME + "Pre" + IO.XMLSUFFIX);
bw.write(logReport.toString());
write(bw, report + NAME + "Pos" + IO.XMLSUFFIX);
bw.close();
}
Util.outln("Total #Queries: " + total);
Util.outln("Correct / Empty results: " + ok + " / " + ok2);
Util.out("Conformance (w/empty results): ");
Util.outln(pc(ok, total) + " / " + pc(ok + ok2, total));
Util.outln("Total Time: " + time);
context.close();
}
/** Stop BaseX HTTP. */
private void stopBaseXHTTP() {
Util.start(BaseXHTTP.class, "stop");
Performance.sleep(TIMEOUT); // give the server some time to stop
}
/** Start BaseX HTTP. */
private void startBaseXHTTP() {
Util.start(BaseXHTTP.class, "-U" + UserText.ADMIN, "-P" + UserText.ADMIN);
Performance.sleep(TIMEOUT); // give the server some time to stop
}
/**
* Evaluates the specified query.
*
* @param query query
* @return success flag
*/
final boolean query(final String query) {
final Performance p = new Performance();
String error;
if (exception != null) {
error = Util.message(exception);
} else {
try {
long hits = 0;
final boolean run = options.get(MainOptions.RUNQUERY);
final boolean serial = options.get(MainOptions.SERIALIZE);
final int runs = Math.max(1, options.get(MainOptions.RUNS));
for (int r = 0; r < runs; ++r) {
// reuse existing processor instance
if (r != 0) qp = null;
qp(query, context);
parse(p);
if (r == 0) plan(false);
qp.compile();
info.compiling += p.time();
if (r == 0) plan(true);
if (!run) continue;
final PrintOutput po = r == 0 && serial ? out : new NullOutput();
try (final Serializer ser = qp.getSerializer(po)) {
if (maxResults >= 0) {
result = qp.cache(maxResults);
info.evaluating += p.time();
result.serialize(ser);
hits = result.size();
} else {
hits = 0;
final Iter ir = qp.iter();
info.evaluating += p.time();
for (Item it; (it = ir.next()) != null; ) {
ser.serialize(it);
++hits;
checkStop();
}
}
}
qp.close();
info.serializing += p.time();
}
// dump some query info
// out.flush();
// remove string list if global locking is used and if query is updating
if (soptions.get(StaticOptions.GLOBALLOCK) && qp.updating) {
info.readLocked = null;
info.writeLocked = null;
}
return info(info.toString(qp, out.size(), hits, options.get(MainOptions.QUERYINFO)));
} catch (final QueryException | IOException ex) {
exception = ex;
error = Util.message(ex);
} catch (final ProcException ex) {
error = INTERRUPTED;
} catch (final StackOverflowError ex) {
Util.debug(ex);
error = BASX_STACKOVERFLOW.desc;
} catch (final RuntimeException ex) {
extError("");
Util.debug(info());
throw ex;
} finally {
// close processor after exceptions
if (qp != null) qp.close();
}
}
return extError(error);
}
@Override
public void run() {
// initialize the session via cram-md5 authentication
try {
final String ts = Long.toString(System.nanoTime());
final byte[] address = socket.getInetAddress().getAddress();
// send {TIMESTAMP}0
out = PrintOutput.get(socket.getOutputStream());
out.print(ts);
send(true);
// evaluate login data
in = new BufferInput(socket.getInputStream());
// receive {USER}0{PASSWORD}0
final String us = in.readString();
final String pw = in.readString();
context.user = context.users.get(us);
running = context.user != null && md5(string(context.user.password) + ts).equals(pw);
// write log information
if (running) {
log.write(this, "LOGIN " + context.user.name, OK);
// send {OK}
send(true);
server.unblock(address);
context.add(this);
} else {
if (!us.isEmpty()) log.write(this, ACCESS_DENIED + COLS + us);
new ClientDelayer(server.block(address), this, server).start();
}
} catch (final IOException ex) {
Util.stack(ex);
log.write(ex.getMessage());
return;
}
if (!running) return;
// authentification done, start command loop
ServerCmd sc = null;
String cmd = null;
try {
while (running) {
command = null;
try {
final int b = in.read();
if (b == -1) {
// end of stream: exit session
quit();
break;
}
last = System.currentTimeMillis();
perf.time();
sc = ServerCmd.get(b);
cmd = null;
if (sc == ServerCmd.CREATE) {
create();
} else if (sc == ServerCmd.ADD) {
add();
} else if (sc == ServerCmd.WATCH) {
watch();
} else if (sc == ServerCmd.UNWATCH) {
unwatch();
} else if (sc == ServerCmd.REPLACE) {
replace();
} else if (sc == ServerCmd.STORE) {
store();
} else if (sc != ServerCmd.COMMAND) {
query(sc);
} else {
// database command
cmd = new ByteList().add(b).add(in.readBytes()).toString();
}
} catch (final IOException ex) {
// this exception may be thrown if a session is stopped
quit();
break;
}
if (sc != ServerCmd.COMMAND) continue;
// parse input and create command instance
try {
command = new CommandParser(cmd, context).parseSingle();
} catch (final QueryException ex) {
// log invalid command
final String msg = ex.getMessage();
log.write(this, cmd, ERROR_C + msg);
// send 0 to mark end of potential result
out.write(0);
// send {INFO}0
out.writeString(msg);
// send 1 to mark error
send(false);
continue;
}
// start timeout
command.startTimeout(context.mprop.num(MainProp.TIMEOUT));
log.write(this, command.toString().replace('\r', ' ').replace('\n', ' '));
// execute command and send {RESULT}
boolean ok = true;
String info;
try {
command.execute(context, new EncodingOutput(out));
info = command.info();
} catch (final BaseXException ex) {
ok = false;
info = ex.getMessage();
if (info.startsWith(INTERRUPTED)) info = TIMEOUT_EXCEEDED;
}
// stop timeout
command.stopTimeout();
// send 0 to mark end of result
out.write(0);
// send info
info(info, ok);
// stop console
if (command instanceof Exit) {
command = null;
quit();
}
}
} catch (final IOException ex) {
log.write(this, sc == ServerCmd.COMMAND ? cmd : sc, ERROR_C + ex.getMessage());
Util.debug(ex);
command = null;
quit();
}
command = null;
}
/**
* Constructor.
*
* @param ctx database context
* @param args command-line arguments
* @throws IOException I/O exception
*/
public BaseXServer(final Context ctx, final String... args) throws IOException {
super(args, ctx);
final MainProp mprop = context.mprop;
final int port = mprop.num(MainProp.SERVERPORT);
final int eport = mprop.num(MainProp.EVENTPORT);
// check if ports are distinct
if (port == eport) throw new BaseXException(PORT_TWICE_X, port);
final String host = mprop.get(MainProp.SERVERHOST);
final InetAddress addr = host.isEmpty() ? null : InetAddress.getByName(host);
if (service) {
start(port, args);
Util.outln(SRV_STARTED);
Performance.sleep(1000);
return;
}
if (stopped) {
stop(port, eport);
Util.outln(SRV_STOPPED);
Performance.sleep(1000);
return;
}
try {
// execute command-line arguments
for (final String c : commands) execute(c);
log = new Log(context, quiet);
log.write(SRV_STARTED);
socket = new ServerSocket();
socket.setReuseAddress(true);
socket.bind(new InetSocketAddress(addr, port));
esocket = new ServerSocket();
esocket.setReuseAddress(true);
esocket.bind(new InetSocketAddress(addr, eport));
stop = stopFile(port);
// show info when server is aborted
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
@Override
public void run() {
log.write(SRV_STOPPED);
log.close();
Util.outln(SRV_STOPPED);
}
});
new Thread(this).start();
while (!running) Performance.sleep(100);
Util.outln(CONSOLE + (console ? TRY_MORE_X : SRV_STARTED), SERVERMODE);
if (console) {
console();
quit();
}
} catch (final IOException ex) {
if (log != null) log.write(ex.getMessage());
throw ex;
}
}
