/** Saves the displayed text. */
private void save() {
final BaseXFileChooser fc =
new BaseXFileChooser(SAVE_AS, gui.gopts.get(GUIOptions.WORKPATH), gui).suffix(IO.XMLSUFFIX);
final IO file = fc.select(Mode.FSAVE);
if (file == null) return;
gui.gopts.set(GUIOptions.WORKPATH, file.path());
gui.cursor(CURSORWAIT, true);
final MainOptions opts = gui.context.options;
final int mh = opts.get(MainOptions.MAXHITS);
opts.set(MainOptions.MAXHITS, -1);
opts.set(MainOptions.CACHEQUERY, false);
try (final PrintOutput out = new PrintOutput(file.toString())) {
if (cmd != null) {
cmd.execute(gui.context, out);
} else if (ns != null) {
ns.serialize(Serializer.get(out));
} else {
final byte[] txt = text.getText();
for (final byte t : txt) if (t < 0 || t > ' ' || ws(t)) out.write(t);
}
} catch (final IOException ex) {
BaseXDialog.error(gui, Util.info(FILE_NOT_SAVED_X, file));
} finally {
opts.set(MainOptions.MAXHITS, mh);
opts.set(MainOptions.CACHEQUERY, true);
gui.cursor(CURSORARROW, true);
}
}
/**
* 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) {
}
}
}
/**
* Constructor, specifying the server host:port combination, login data and an output stream.
*
* @param host server name
* @param port server port
* @param user user name
* @param pass password
* @param output client output; if set to {@code null}, results will be returned as strings.
* @throws IOException I/O exception
*/
public ClientSession(
final String host,
final int port,
final String user,
final String pass,
final OutputStream output)
throws IOException {
super(output);
ehost = host;
socket = new Socket();
try {
// limit timeout to five seconds
socket.connect(new InetSocketAddress(host, port), 5000);
} catch (final IllegalArgumentException ex) {
throw new BaseXException(ex);
}
sin = socket.getInputStream();
// receive timestamp
final BufferInput bi = new BufferInput(sin);
final String ts = bi.readString();
// send user name and hashed password/timestamp
sout = PrintOutput.get(socket.getOutputStream());
send(user);
send(Token.md5(Token.md5(pass) + ts));
sout.flush();
// receive success flag
if (!ok(bi)) throw new LoginException();
}
/**
* Sends the specified stream to the server.
*
* @param input input stream
* @throws IOException I/O exception
*/
private void send(final InputStream input) throws IOException {
final EncodingOutput eo = new EncodingOutput(sout);
for (int b; (b = input.read()) != -1; ) eo.write(b);
sout.write(0);
sout.flush();
receive(null);
}
/**
* Stores the specified source to the specified file.
*
* @param in input source
* @param file target file
* @throws IOException I/O exception
*/
public static void store(final InputSource in, final IOFile file) throws IOException {
// add directory if it does not exist anyway
file.dir().md();
final PrintOutput po = new PrintOutput(file.path());
try {
final Reader r = in.getCharacterStream();
final InputStream is = in.getByteStream();
final String id = in.getSystemId();
if (r != null) {
for (int c; (c = r.read()) != -1; ) po.utf8(c);
} else if (is != null) {
for (int b; (b = is.read()) != -1; ) po.write(b);
} else if (id != null) {
final BufferInput bi = new BufferInput(IO.get(id));
try {
for (int b; (b = bi.read()) != -1; ) po.write(b);
} finally {
bi.close();
}
}
} finally {
po.close();
}
}
/**
* Unwatches an event.
*
* @param name event name
* @throws IOException I/O exception
*/
public void unwatch(final String name) throws IOException {
sout.write(ServerCmd.UNWATCH.code);
send(name);
sout.flush();
receive(null);
notifiers.remove(name);
}
/**
* Indents the next text.
*
* @throws IOException I/O exception
*/
protected void indent() throws IOException {
if (indent) {
out.print('\n');
final int ls = level * indents;
for (int l = 0; l < ls; l++) out.print(tab);
}
}
/**
* Constructor.
*
* @param os output stream
* @param sopts serializer options
* @throws QueryIOException query I/O exception
*/
protected OutputSerializer(final OutputStream os, final SerializerOptions sopts)
throws QueryIOException {
this.sopts = sopts;
indent = sopts.yes(INDENT);
// project-specific options
indents = sopts.get(INDENTS);
tab = sopts.yes(TABULATOR) ? '\t' : ' ';
encoding = Strings.normEncoding(sopts.get(ENCODING), true);
PrintOutput po;
if (encoding == Strings.UTF8) {
po = PrintOutput.get(os);
} else {
try {
po = new EncoderOutput(os, Charset.forName(encoding));
} catch (final Exception ex) {
throw SERENCODING_X.getIO(encoding);
}
}
final int limit = sopts.get(LIMIT);
if (limit != -1) po.setLimit(limit);
final byte[] nl = token(sopts.get(NEWLINE).newline());
if (nl.length != 1 || nl[0] != '\n') po = new NewlineOutput(po, nl);
out = po;
}
/**
* Executes a command and sends the result to the specified output stream.
*
* @param cmd server command
* @param arg argument
* @param os target output stream
* @return string
* @throws IOException I/O exception
*/
protected String exec(final ServerCmd cmd, final String arg, final OutputStream os)
throws IOException {
final OutputStream o = os == null ? new ArrayOutput() : os;
sout.write(cmd.code);
send(arg);
sout.flush();
final BufferInput bi = new BufferInput(sin);
ClientSession.receive(bi, o);
if (!ClientSession.ok(bi)) throw new BaseXException(bi.readString());
return o.toString();
}
/**
* Returns a hex entity for the specified codepoint.
*
* @param cp codepoint
* @throws IOException I/O exception
*/
protected final void printHex(final int cp) throws IOException {
out.print("&#x");
boolean o = false;
for (int i = 3; i >= 0; i--) {
final int b = (cp >> (i << 3)) & 0xFF;
if (o || b > 0x0F) {
out.print(HEX[b >> 4]);
}
if (o || b != 0) {
out.print(HEX[b & 0xF]);
o = true;
}
}
out.print(';');
}
/**
* Sends the specified command, string arguments and input.
*
* @param cmd command
* @param input input stream
* @param strings string arguments
* @throws IOException I/O exception
*/
protected void send(final ServerCmd cmd, final InputStream input, final String... strings)
throws IOException {
sout.write(cmd.code);
for (final String s : strings) send(s);
send(input);
}
/**
* Watches an event.
*
* @param name event name
* @param notifier event notification
* @throws IOException I/O exception
*/
public void watch(final String name, final EventNotifier notifier) throws IOException {
sout.write(ServerCmd.WATCH.code);
if (esocket == null) {
sout.flush();
final BufferInput bi = new BufferInput(sin);
final int eport = Integer.parseInt(bi.readString());
// initialize event socket
esocket = new Socket();
esocket.connect(new InetSocketAddress(ehost, eport), 5000);
final OutputStream so = esocket.getOutputStream();
so.write(bi.readBytes());
so.write(0);
so.flush();
final InputStream is = esocket.getInputStream();
is.read();
listen(is);
}
send(name);
sout.flush();
receive(null);
notifiers.put(name, notifier);
}
@Override
protected void execute(final String cmd, final OutputStream os) throws IOException {
send(cmd);
sout.flush();
receive(os);
}
/**
* Sends a string to the server.
*
* @param s string to be sent
* @throws IOException I/O exception
*/
protected void send(final String s) throws IOException {
sout.write(Token.token(s));
sout.write(0);
}
/**
* Encodes the specified codepoint before printing.
*
* @param cp codepoint to be encoded and printed
* @throws IOException I/O exception
*/
protected void printChar(final int cp) throws IOException {
out.print(cp);
}
@Override
public void close() throws IOException {
out.flush();
}
@Override
public final boolean finished() {
return out.finished();
}
