/**
* 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();
}
}
@Override
public void execute(final GUI gui) {
final DialogExport dialog = new DialogExport(gui);
if (!dialog.ok()) return;
final IOFile root = new IOFile(dialog.path());
// check if existing files will be overwritten
if (root.exists()) {
IO file = null;
boolean overwrite = false;
final Data d = gui.context.data();
final IntList il = d.resources.docs();
final int is = il.size();
for (int i = 0; i < is; i++) {
file = root.merge(Token.string(d.text(il.get(i), true)));
if (file.exists()) {
if (overwrite) {
// more than one file will be overwritten; check remaining tests
file = null;
break;
}
overwrite = true;
}
}
if (overwrite) {
// show message for overwriting files or directories
final String msg = file == null ? FILES_REPLACE_X : FILE_EXISTS_X;
if (file == null) file = root;
if (!BaseXDialog.confirm(gui, Util.info(msg, file))) return;
}
}
DialogProgress.execute(gui, new Export(root.path()));
}
/**
* Returns a list of all databases.
*
* @param ctx database context
* @return list of databases
*/
public static StringList list(final Context ctx) {
final StringList db = new StringList();
for (final IOFile f : ctx.mprop.dbpath().children()) {
final String name = f.name();
if (f.isDir() && !name.startsWith(".")) db.add(name);
}
return db.sort(false);
}
@Override
public void startUpdate(final MainOptions opts) throws IOException {
if (!table.lock(true)) throw new BaseXException(Text.DB_PINNED_X, meta.name);
if (opts.get(MainOptions.AUTOFLUSH)) {
final IOFile uf = meta.updateFile();
if (uf.exists()) throw new BaseXException(Text.DB_UPDATED_X, meta.name);
if (!uf.touch()) throw Util.notExpected("%: could not create lock file.", meta.name);
}
}
/**
* Checks if the table of the specified database is locked.
*
* @param db name of database
* @param ctx database context
* @return result of check
*/
public static boolean locked(final String db, final Context ctx) {
final IOFile table = MetaData.file(ctx.globalopts.dbpath(db), DATATBL);
if (!table.exists()) return false;
try (final RandomAccessFile file = new RandomAccessFile(table.file(), "rw")) {
return file.getChannel().tryLock() == null;
} catch (final ClosedChannelException ex) {
return false;
} catch (final OverlappingFileLockException | IOException ex) {
return true;
}
}
@Override
public synchronized void finishUpdate(final MainOptions opts) {
// remove updating file
final boolean auto = opts.get(MainOptions.AUTOFLUSH);
if (auto) {
final IOFile uf = meta.updateFile();
if (!uf.exists()) throw Util.notExpected("%: lock file does not exist.", meta.name);
if (!uf.delete()) throw Util.notExpected("%: could not delete lock file.", meta.name);
}
// db:optimize(..., true) will close the database before this function is called
if (!closed) {
flush(auto);
if (!table.lock(false)) throw Util.notExpected("Database '%': could not unlock.", meta.name);
}
}
/**
* Chooses files that match the specified pattern.
*
* @param file file filter
* @param content content filter
* @param root root directory
* @return sorted file paths
* @throws InterruptedException interruption
*/
String[] filter(final String file, final String content, final IOFile root)
throws InterruptedException {
final long id = ++filterId;
final TreeSet<String> results = new TreeSet<>();
final int[] search = new TokenParser(Token.lc(Token.token(content))).toArray();
// glob pattern
final ProjectCache pc = cache(root);
if (file.contains("*") || file.contains("?")) {
final Pattern pt = Pattern.compile(IOFile.regex(file));
for (final String path : pc) {
final int offset = offset(path, true);
if (pt.matcher(path.substring(offset)).matches() && filterContent(path, search)) {
results.add(path);
if (results.size() >= MAXHITS) break;
}
if (id != filterId) throw new InterruptedException();
}
} else {
// starts-with, contains, camel case
final String pttrn = file.toLowerCase(Locale.ENGLISH).replace('\\', '/');
final HashSet<String> exclude = new HashSet<>();
final boolean pathSearch = pttrn.indexOf('/') != -1;
for (int i = 0; i < (pathSearch ? 2 : 3); i++) {
filter(pttrn, search, i, results, exclude, pathSearch, pc, id);
}
}
return results.toArray(new String[results.size()]);
}
/**
* Refreshes the list of recent query files and updates the query path.
*
* @param file new file
*/
void refreshHistory(final IOFile file) {
final StringList sl = new StringList();
String path = null;
if (file != null) {
path = file.path();
gui.gprop.set(GUIProp.WORKPATH, file.dirPath());
sl.add(path);
tabs.setToolTipTextAt(tabs.getSelectedIndex(), path);
}
final String[] qu = gui.gprop.strings(GUIProp.EDITOR);
for (int q = 0; q < qu.length && q < 19; q++) {
final String f = qu[q];
if (!f.equalsIgnoreCase(path) && IO.get(f).exists()) sl.add(f);
}
// store sorted history
gui.gprop.set(GUIProp.EDITOR, sl.toArray());
hist.setEnabled(!sl.isEmpty());
}
/**
* Tests writing of request content when @src is set.
*
* @throws IOException I/O Exception
*/
@Test
public void writeFromResource() throws IOException {
// Create a file form which will be read
final IOFile file = new IOFile(Prop.TMP, Util.className(FnHttpTest.class));
file.write(token("test"));
// Request
final HttpRequest req = new HttpRequest();
req.payloadAttrs.put("src", file.url());
req.payloadAttrs.put("method", "binary");
// HTTP connection
final FakeHttpConnection fakeConn = new FakeHttpConnection(new URL("http://www.test.com"));
HttpClient.setRequestContent(fakeConn.getOutputStream(), req);
// Delete file
file.delete();
assertEquals(fakeConn.out.toString(Strings.UTF8), "test");
}
/**
* Refreshes the view after a file has been saved.
*
* @param root root directory
* @param ctx database context
* @throws InterruptedException interruption
*/
void parse(final IOFile root, final Context ctx) throws InterruptedException {
final long id = ++parseId;
final HashSet<String> parsed = new HashSet<>();
final TreeMap<String, InputInfo> errs = new TreeMap<>();
// collect files to be parsed
final ProjectCache pc = cache(root);
final StringList mods = new StringList(), lmods = new StringList();
for (final String path : pc) {
final IOFile file = new IOFile(path);
if (file.hasSuffix(IO.XQSUFFIXES)) (file.hasSuffix(IO.XQMSUFFIX) ? lmods : mods).add(path);
}
mods.add(lmods);
// parse modules
for (final String path : mods) {
if (id != parseId) throw new InterruptedException();
if (parsed.contains(path)) continue;
final IOFile file = new IOFile(path);
try (final TextInput ti = new TextInput(file)) {
// parse query
try (final QueryContext qc = new QueryContext(ctx)) {
final String input = ti.cache().toString();
final boolean lib = QueryProcessor.isLibrary(input);
qc.parse(input, lib, path, null);
// parsing was successful: remember path
parsed.add(path);
for (final byte[] mod : qc.modParsed) parsed.add(Token.string(mod));
} catch (final QueryException ex) {
// parsing failed: remember path
final InputInfo ii = ex.info();
errs.put(path, ii);
parsed.add(ii.path());
}
} catch (final IOException ex) {
// file may not be accessible
Util.debug(ex);
}
}
errors = errs;
}
/**
* Saves the specified editor contents.
*
* @param file file to write
* @return {@code false} if confirmation was canceled
*/
private boolean save(final IOFile file) {
try {
final EditorArea edit = getEditor();
file.write(edit.getText());
edit.file(file);
return true;
} catch (final IOException ex) {
BaseXDialog.error(gui, FILE_NOT_SAVED);
return false;
}
}
@Override
protected boolean run() throws IOException {
final String path = MetaData.normPath(args[0]);
if (path == null) return error(NAME_INVALID_X, args[0]);
final IOFile bin = context.data().meta.binary(path);
if (bin == null || !bin.exists() || bin.isDir()) return error(RES_NOT_FOUND_X, path);
try {
final BufferInput bi = new BufferInput(bin);
try {
for (int b; (b = bi.read()) != -1; ) out.write(b);
} finally {
bi.close();
}
return info(QUERY_EXECUTED_X, perf);
} catch (final IOException ex) {
return error(FILE_NOT_STORED_X, ex);
}
}
/**
* Lists all databases.
*
* @return success flag
* @throws IOException I/O exception
*/
private boolean list() throws IOException {
final Table table = new Table();
table.description = DATABASES_X;
final boolean create = context.user.has(Perm.CREATE);
table.header.add(T_NAME);
table.header.add(RESOURCES);
table.header.add(SIZE);
if (create) table.header.add(INPUT_PATH);
for (final String name : context.databases.listDBs()) {
String file = null;
long size = 0;
int docs = 0;
final MetaData meta = new MetaData(name, context);
try {
meta.read();
size = meta.dbsize();
docs = meta.ndocs;
if (context.perm(Perm.READ, meta)) file = meta.original;
} catch (final IOException ex) {
file = ERROR;
}
// count number of raw files
final IOFile dir = new IOFile(mprop.dbpath(name), M_RAW);
final int bin = dir.descendants().size();
// create entry
if (file != null) {
final TokenList tl = new TokenList(4);
tl.add(name);
tl.add(docs + bin);
tl.add(size);
if (create) tl.add(file);
table.contents.add(tl);
}
}
out.println(table.sort().finish());
return true;
}
@Override
public void action(final Object comp) {
final String pth = path();
final IOFile io = new IOFile(pth);
String inf = io.isDir() && io.children().length > 0 ? DIR_NOT_EMPTY : null;
ok = !pth.isEmpty();
final SerialMethod mth = SerialMethod.valueOf(method.getSelectedItem());
final OptionsOption<? extends Options> opts =
mth == SerialMethod.JSON
? SerializerOptions.JSON
: mth == SerialMethod.CSV ? SerializerOptions.CSV : null;
final boolean showmparams = opts != null;
mparams.setEnabled(showmparams);
if (ok) {
gui.gopts.set(GUIOptions.INPUTPATH, pth);
try {
if (comp == method) {
if (showmparams) {
final Options mopts = options(null).get(opts);
mparams.setToolTipText(tooltip(mopts));
mparams.setText(mopts.toString());
} else {
mparams.setToolTipText(null);
mparams.setText("");
}
}
Serializer.get(new ArrayOutput(), options(mth));
} catch (final IOException ex) {
ok = false;
inf = ex.getMessage();
}
}
info.setText(inf, ok ? Msg.WARN : Msg.ERROR);
enableOK(buttons, B_OK, ok);
}
@Override
protected boolean run() {
final boolean create = context.user.has(Perm.CREATE);
String path = MetaData.normPath(args[0]);
if (path == null || path.endsWith(".")) return error(NAME_INVALID_X, args[0]);
if (in == null) {
final IO io = IO.get(args[1]);
if (!io.exists() || io.isDir()) return error(RES_NOT_FOUND_X, create ? io : args[1]);
in = io.inputSource();
// set/add name of document
if ((path.isEmpty() || path.endsWith("/")) && !(io instanceof IOContent)) path += io.name();
}
// ensure that the final name is not empty
if (path.isEmpty()) return error(NAME_INVALID_X, path);
// ensure that the name is not empty and contains no trailing dots
final Data data = context.data();
if (data.inMemory()) return error(NO_MAINMEM);
final IOFile file = data.meta.binary(path);
if (path.isEmpty() || path.endsWith(".") || file == null || file.isDir())
return error(NAME_INVALID_X, create ? path : args[0]);
// start update
if (!data.startUpdate()) return error(DB_PINNED_X, data.meta.name);
try {
store(in, file);
return info(QUERY_EXECUTED_X_X, "", perf);
} catch (final IOException ex) {
return error(FILE_NOT_STORED_X, Util.message(ex));
} finally {
data.finishUpdate();
}
}
/**
* Recursively populates the cache.
*
* @param root root directory
* @param pc file cache
* @throws InterruptedException interruption
*/
void add(final IOFile root, final ProjectCache pc) throws InterruptedException {
// check if file cache was replaced or invalidated
if (pc != cache) throw new InterruptedException();
final IOFile[] files = root.children();
for (final IOFile file : files) {
if (file.name().equals(IO.IGNORESUFFIX)) return;
}
for (final IOFile file : files) {
if (file.isDir()) {
add(file, pc);
} else {
pc.add(file.path());
}
}
}
/**
* Opens the specified query file.
*
* @param file query file
* @return opened editor
*/
public EditorArea open(final IOFile file) {
if (!visible()) GUICommands.C_SHOWEDITOR.execute(gui);
EditorArea edit = find(file, true);
try {
if (edit != null) {
// display open file
tabs.setSelectedComponent(edit);
edit.reopen(true);
} else {
// get current editor
edit = getEditor();
// create new tab if current text is stored on disk or has been modified
if (edit.opened() || edit.modified) edit = addTab();
edit.initText(file.read());
edit.file(file);
}
} catch (final IOException ex) {
BaseXDialog.error(gui, FILE_NOT_OPENED);
}
return edit;
}
/** Opens a file dialog to choose an XML document or directory. */
private void choose() {
final IOFile io = new BaseXFileChooser(CHOOSE_DIR, path.getText(), gui).select(Mode.DOPEN);
if (io != null) path.setText(io.path());
}
