@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final Data data = checkData(qc);
final String path = path(1, qc);
final Item item = toItem(exprs[2], qc);
final Options opts = toOptions(3, Q_OPTIONS, new Options(), qc);
final Updates updates = qc.resources.updates();
final IntList docs = data.resources.docs(path);
int d = 0;
// delete binary resources
final IOFile bin = data.meta.binary(path);
if (bin == null || bin.isDir()) throw BXDB_REPLACE_X.get(info, path);
if (item instanceof Bin) {
updates.add(new DBStore(data, path, item, info), qc);
} else {
if (bin.exists()) updates.add(new DBDelete(data, path, info), qc);
final NewInput input = checkInput(item, token(path));
if (docs.isEmpty() || docs.get(0) == 0) {
// no replacement of first document (because of TableDiskAccess#insert, used > 0, pre = 0)
updates.add(new DBAdd(data, input, opts, qc, info), qc);
} else {
updates.add(new ReplaceDoc(docs.get(0), data, input, opts, qc, info), qc);
d = 1;
}
}
// delete old documents
final int ds = docs.size();
for (; d < ds; d++) updates.add(new DeleteNode(docs.get(d), data, info), qc);
return null;
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final Data data = checkData(qc);
final String path = path(1, qc);
if (data.inMemory()) return Bln.FALSE;
final IOFile io = data.meta.binary(path);
return Bln.get(io.exists() && !io.isDir());
}
/**
* 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()]);
}
/**
* 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;
}
/**
* 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());
}
}
}
@Override
public B64 item(final QueryContext qc, final InputInfo ii) throws QueryException {
checkCreate(qc);
final IOFile root = new IOFile(toPath(0, qc).toString());
final ArchOptions opts = toOptions(1, Q_OPTIONS, new ArchOptions(), qc);
final Iter entries;
if (exprs.length > 2) {
entries = qc.iter(exprs[2]);
} else {
final TokenList tl = new TokenList();
for (final String file : root.descendants()) tl.add(file);
entries = StrSeq.get(tl).iter();
}
final String format = opts.get(ArchOptions.FORMAT);
final int level = level(opts);
if (!root.isDir()) throw FILE_NO_DIR_X.get(info, root);
try (final ArchiveOut out = ArchiveOut.get(format.toLowerCase(Locale.ENGLISH), info)) {
out.level(level);
try {
while (true) {
Item en = entries.next();
if (en == null) break;
en = checkElemToken(en);
final IOFile file = new IOFile(root, string(en.string(info)));
if (!file.exists()) throw FILE_NOT_FOUND_X.get(info, file);
if (file.isDir()) throw FILE_IS_DIR_X.get(info, file);
add(en, new B64(file.read()), out, level, qc);
}
} catch (final IOException ex) {
throw ARCH_FAIL_X.get(info, ex);
}
return new B64(out.finish());
}
}