@Override
public void configure(Map<String, String> parameters)
throws IllegalArgumentException, IllegalStateException {
if (this.parameters != null) {
throw new IllegalStateException(
"cannot change configuration, may be already in use somewhere");
}
directoryName = parameters.get(PARAM_DIRECTORY);
if (directoryName != null) {
directoryName = directoryName.trim();
}
if (directoryName == null || directoryName.isEmpty()) {
throw new IllegalArgumentException(
"missing directory parameter. A directory name is necessary");
}
fetchDirectory();
idField = directory.getIdField();
schema = directory.getSchema();
if (schema.endsWith("xvocabulary")) {
hierarchical = true;
parentField = "parent";
separator = "/";
}
String parentFieldParam = StringUtils.trim(parameters.get(PARAM_PARENT_FIELD));
String separatorParam = StringUtils.trim(parameters.get(PARAM_SEPARATOR));
if (!StringUtils.isBlank(parentFieldParam) && !StringUtils.isBlank(separatorParam)) {
hierarchical = true;
parentField = parentFieldParam;
separator = separatorParam;
}
this.parameters = new HashMap<String, Serializable>();
this.parameters.put(PARAM_DIRECTORY, directory.getName());
}
@Ignore // git based vfs does not yet support move
@Test
public void testMoveEmptyDirectory() throws NoSuchFileException {
Repository repository = new VFSRepository(producer.getIoService());
((VFSRepository) repository).setDescriptor(descriptor);
Directory sourceDir = repository.createDirectory("/source");
boolean directoryExists =
repository.directoryExists(sourceDir.getLocation() + sourceDir.getName());
assertTrue(directoryExists);
Collection<Asset> foundAsset = repository.listAssets("/source", new FilterByExtension("bpmn2"));
assertNotNull(foundAsset);
assertEquals(0, foundAsset.size());
boolean copied = repository.moveDirectory("/source", "/", "target");
assertTrue(copied);
boolean movedDirectoryExists = repository.directoryExists("/source");
assertFalse(movedDirectoryExists);
movedDirectoryExists = repository.directoryExists("/target");
assertTrue(movedDirectoryExists);
foundAsset = repository.listAssets("/target", new FilterByExtension("bpmn2"));
assertNotNull(foundAsset);
assertEquals(0, foundAsset.size());
}
/**
* This helper method determines how a list of elements should be presented to the user, based on
* options given in the instruction.
*
* @param elements the file system elements to be listed
* @param instruction the instruction instance created based on the user input
*/
private void showResult(ArrayList<FileSystemElement> elements, Instruction instruction) {
ArrayList<String> options = instruction.getOptions();
if (!elements.isEmpty()) {
if (options.contains("l")) {
int totalSize = 0;
for (FileSystemElement element : elements) {
totalSize += element.getSize();
}
System.out.printf("total %d%n", totalSize);
for (FileSystemElement element : elements) {
System.out.printf("%s%n", element);
}
} else {
for (FileSystemElement element : elements) {
System.out.printf("%s%n", element.getName());
}
}
if (options.contains("R")) {
for (FileSystemElement element : elements) {
if (element instanceof Directory) {
Directory directory = (Directory) element;
showResult(directory.getChildren(), instruction);
}
}
}
}
}
@Test
public void testDirectoryExists() {
Repository repository = new VFSRepository(producer.getIoService());
((VFSRepository) repository).setDescriptor(descriptor);
boolean rootFolderExists = repository.directoryExists("/test");
assertFalse(rootFolderExists);
Directory directoryId = repository.createDirectory("/test");
assertNotNull(directoryId);
assertEquals("test", directoryId.getName());
assertEquals("/", directoryId.getLocation());
assertNotNull(directoryId.getUniqueId());
rootFolderExists = repository.directoryExists("/test");
assertTrue(rootFolderExists);
AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Byte);
builder.content("simple content".getBytes()).type("png").name("test").location("/test");
String id = repository.createAsset(builder.getAsset());
assertNotNull(id);
boolean assetPathShouldNotExists = repository.directoryExists("/test/test.png");
assertFalse(assetPathShouldNotExists);
}
/**
* @param sName
* @param dParentDirectory
* @return ItemManager ID
*/
protected static String createID(String sName, Directory dParentDirectory) {
return MD5Processor.hash(
new StringBuilder(dParentDirectory.getDevice().getName())
.append(dParentDirectory.getRelativePath())
.append(sName)
.toString());
}
public void testRAMDirectory() throws IOException {
Directory dir = newFSDirectory(indexDir);
MockDirectoryWrapper ramDir = new MockDirectoryWrapper(random, new RAMDirectory(dir));
// close the underlaying directory
dir.close();
// Check size
assertEquals(ramDir.sizeInBytes(), ramDir.getRecomputedSizeInBytes());
// open reader to test document count
IndexReader reader = IndexReader.open(ramDir, true);
assertEquals(docsToAdd, reader.numDocs());
// open search zo check if all doc's are there
IndexSearcher searcher = newSearcher(reader);
// search for all documents
for (int i = 0; i < docsToAdd; i++) {
Document doc = searcher.doc(i);
assertTrue(doc.getField("content") != null);
}
// cleanup
reader.close();
searcher.close();
}
public IndexOutput createOutput(String name, IOContext context, boolean raw)
throws IOException {
Directory directory;
if (isChecksum(name)) {
directory = distributor.primary();
} else {
directory = distributor.any();
}
IndexOutput out = directory.createOutput(name, context);
synchronized (mutex) {
StoreFileMetaData metaData = new StoreFileMetaData(name, -1, null, directory);
filesMetadata = MapBuilder.newMapBuilder(filesMetadata).put(name, metaData).immutableMap();
files = filesMetadata.keySet().toArray(new String[filesMetadata.size()]);
boolean computeChecksum = !raw;
if (computeChecksum) {
// don't compute checksum for segment based files
if ("segments.gen".equals(name) || name.startsWith("segments")) {
computeChecksum = false;
}
}
if (computeChecksum) {
out = new BufferedChecksumIndexOutput(out, new Adler32());
}
return new StoreIndexOutput(metaData, out, name);
}
}
public void updateEntry(String name, EntryConfig entryConfig) throws Exception {
log.debug(TextUtil.repeat("-", 70));
Directory directory = getDirectory();
List<Entry> children = null;
if (directory != null) {
try {
Entry oldEntry = directory.removeEntry(entryConfig.getName());
if (oldEntry != null) {
children = oldEntry.getChildren();
oldEntry.destroy();
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
removeEntryService(entryConfig.getName());
DirectoryConfig directoryConfig = getDirectoryConfig();
directoryConfig.updateEntryConfig(name, entryConfig);
if (directory != null) {
try {
Entry newEntry = directory.createEntry(entryConfig);
if (children != null) newEntry.addChildren(children);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
createEntryService(entryConfig.getName());
}
private static void print(Metadata metadata) {
System.out.println("-------------------------------------");
// Iterate over the data and print to System.out
//
// A Metadata object contains multiple Directory objects
//
for (Directory directory : metadata.getDirectories()) {
//
// Each Directory stores values in Tag objects
//
for (Tag tag : directory.getTags()) {
System.out.println(tag);
}
//
// Each Directory may also contain error messages
//
if (directory.hasErrors()) {
for (String error : directory.getErrors()) {
System.err.println("ERROR: " + error);
}
}
}
}
public void valueChanged(ListSelectionEvent e) {
ListSelectionModel lsm = (ListSelectionModel) e.getSource();
int index = list.getSelectedIndex();
Directory dir = directoryList.getDirectory(index);
waitField.setValue(dir.getWaitInterval());
checkField.setValue(dir.getInterval());
if (dir.copy) {
copyButton.setSelected(true);
} else {
moveButton.setSelected(true);
}
if (dir.destination != null) {
destination.setText("Destination Directory: " + dir.destination.toString());
startButton.setEnabled(true);
if (dir.backupNumber == 0) {
startButton.setEnabled(true);
stopButton.setEnabled(false);
} else {
startButton.setEnabled(false);
stopButton.setEnabled(true);
}
} else {
destination.setText("Destination Directory: ");
startButton.setEnabled(false);
}
}
// setup the index
@Override
public void setUp() throws Exception {
super.setUp();
indexDir = _TestUtil.getTempDir("RAMDirIndex");
Directory dir = newFSDirectory(indexDir);
IndexWriter writer =
new IndexWriter(
dir,
new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))
.setOpenMode(OpenMode.CREATE));
// add some documents
Document doc = null;
for (int i = 0; i < docsToAdd; i++) {
doc = new Document();
doc.add(
newField(
"content",
English.intToEnglish(i).trim(),
Field.Store.YES,
Field.Index.NOT_ANALYZED));
writer.addDocument(doc);
}
assertEquals(docsToAdd, writer.maxDoc());
writer.close();
dir.close();
}
// Verify: do stress test, by opening IndexReaders and
// IndexWriters over & over in 2 threads and making sure
// no unexpected exceptions are raised:
public void testStressLocks() throws Exception {
Path tempPath = createTempDir();
assumeFalse("cannot handle buggy Files.delete", TestUtil.hasWindowsFS(tempPath));
Directory dir = getDirectory(tempPath);
// First create a 1 doc index:
IndexWriter w =
new IndexWriter(
dir, new IndexWriterConfig(new MockAnalyzer(random())).setOpenMode(OpenMode.CREATE));
addDoc(w);
w.close();
WriterThread writer = new WriterThread(100, dir);
SearcherThread searcher = new SearcherThread(100, dir);
writer.start();
searcher.start();
while (writer.isAlive() || searcher.isAlive()) {
Thread.sleep(1000);
}
assertTrue("IndexWriter hit unexpected exceptions", !writer.hitException);
assertTrue("IndexSearcher hit unexpected exceptions", !searcher.hitException);
dir.close();
}
static Map<String, String> readChecksums(Directory[] dirs, Map<String, String> defaultValue)
throws IOException {
long lastFound = -1;
Directory lastDir = null;
for (Directory dir : dirs) {
for (String name : dir.listAll()) {
if (!isChecksum(name)) {
continue;
}
long current = Long.parseLong(name.substring(CHECKSUMS_PREFIX.length()));
if (current > lastFound) {
lastFound = current;
lastDir = dir;
}
}
}
if (lastFound == -1) {
return defaultValue;
}
IndexInput indexInput = lastDir.openInput(CHECKSUMS_PREFIX + lastFound, IOContext.READONCE);
try {
indexInput.readInt(); // version
return indexInput.readStringStringMap();
} catch (Exception e) {
// failed to load checksums, ignore and return an empty map
return defaultValue;
} finally {
indexInput.close();
}
}
public void testUpdateSameDoc() throws Exception {
final Directory dir = newDirectory();
final LineFileDocs docs = new LineFileDocs(random());
for (int r = 0; r < 3; r++) {
final IndexWriter w =
new IndexWriter(
dir, newIndexWriterConfig(new MockAnalyzer(random())).setMaxBufferedDocs(2));
final int numUpdates = atLeast(20);
int numThreads = TestUtil.nextInt(random(), 2, 6);
IndexingThread[] threads = new IndexingThread[numThreads];
for (int i = 0; i < numThreads; i++) {
threads[i] = new IndexingThread(docs, w, numUpdates);
threads[i].start();
}
for (int i = 0; i < numThreads; i++) {
threads[i].join();
}
w.close();
}
IndexReader open = DirectoryReader.open(dir);
assertEquals(1, open.numDocs());
open.close();
docs.close();
dir.close();
}
// TODO: Make ln fit the 30 line
public void ln(String firstPath, String secondPath) throws Exception {
// Initialize the variables.
JShellItem targetItem;
JShellItem aliasItem;
String newName;
Directory destinationDirectory;
// Find and reference the target item. Throw Exception if the path
// doesn't exist.
targetItem = getItemAtPath(firstPath, 0);
if (targetItem == null) {
throw new Exception(firstPath + ": doesn't exist.");
}
// Find and reference the destination Directory.
if (secondPath.endsWith("/")) {
destinationDirectory = (Directory) getItemAtPath(secondPath, 0);
newName = targetItem.getName();
} else {
destinationDirectory = (Directory) getItemAtPath(secondPath, 1);
newName = secondPath.substring(secondPath.lastIndexOf("/") + 1);
}
// If the Directory destination is not found.
if (destinationDirectory == null) {
throw new Exception(secondPath + " is an invalid destination path.");
}
// Throw Exception when there is a JShellItem that already exist within
// the destination Directory.
if (destinationDirectory.contains(newName)) {
throw new Exception(secondPath + ": already exists.");
}
// If the target item is a Directory object.
if (targetItem instanceof Directory)
// Create a new Directory object that will references it's contents
// from the target item.
aliasItem =
new DirectoryAlias(
newName,
destinationDirectory.getPath() + newName + "/",
destinationDirectory,
(Directory) targetItem);
// If the target item is a File object.
else
// Create a new FileAlias object that will reference it's contents
// from the target item.
aliasItem =
new FileAlias(
newName,
destinationDirectory.getPath() + newName,
destinationDirectory,
(File) targetItem);
// Add the alias object to the destination Directory.
destinationDirectory.addItem(aliasItem);
}
/** Test ensureValid returns true after acquire */
public void testValidAfterAcquire() throws IOException {
Path tempPath = createTempDir();
Directory dir = getDirectory(tempPath);
Lock l = dir.obtainLock("commit");
l.ensureValid(); // no exception
l.close();
dir.close();
}
public String getDirectoryFilesName(String path, User currentUser, Directory currentDir)
throws FileUnknownException, AccessDeniedException {
if (path.equals(".")) return currentDir.getDirectoryFilesName();
else if (path.equals("..")) return currentDir.getFather().getDirectoryFilesName();
File target = absolutePath(path, currentUser, currentDir).getFileByName(getLastPathToken(path));
target.checkAccessRead(currentUser);
return target.getDirectoryFilesName();
}
public String[] listAll() throws IOException {
String[] primaryFiles = primaryDir.listAll();
String[] secondaryFiles = secondaryDir.listAll();
String[] files = new String[primaryFiles.length + secondaryFiles.length];
System.arraycopy(primaryFiles, 0, files, 0, primaryFiles.length);
System.arraycopy(secondaryFiles, 0, files, primaryFiles.length, secondaryFiles.length);
return files;
}
/** @param args */
public static void main(String[] args) {
// TODO Auto-generated method stub
PPrint.pprint(Directory.walk("src/thinking").dirs);
for (File file : Directory.local("src/thinking/java/space18", "D.*")) {
System.out.println(file);
}
}
String readFile(String path, Directory currentDirectory, User currentUser)
throws FileUnknownException, IsNotPlainFileException, AccessDeniedException {
Directory directory = absolutePath(path, currentUser, currentDirectory);
String filename = getLastPathToken(path);
File f = directory.getFileByName(filename);
f.checkAccessRead(currentUser);
return f.printContent(currentUser);
}
/**
* return ordered child files recursively.
*
* @return child files recursively
*/
public List<org.jajuk.base.File> getFilesRecursively() {
// looks for the root directory for this device
Directory dirRoot = getRootDirectory();
if (dirRoot != null) {
return dirRoot.getFilesRecursively();
}
// nothing found, return empty list
return new ArrayList<org.jajuk.base.File>();
}
@Override
public boolean loadExisting() {
baseGraph.checkInit();
if (properties.loadExisting()) {
properties.checkVersions(false);
// check encoding for compatiblity
String acceptStr = properties.get("graph.flagEncoders");
if (encodingManager == null) {
if (acceptStr.isEmpty())
throw new IllegalStateException(
"No EncodingManager was configured. And no one was found in the graph: "
+ dir.getLocation());
int bytesForFlags = 4;
if ("8".equals(properties.get("graph.bytesForFlags"))) bytesForFlags = 8;
encodingManager = new EncodingManager(acceptStr, bytesForFlags);
} else if (!acceptStr.isEmpty()
&& !encodingManager.toDetailsString().equalsIgnoreCase(acceptStr)) {
throw new IllegalStateException(
"Encoding does not match:\nGraphhopper config: "
+ encodingManager.toDetailsString()
+ "\nGraph: "
+ acceptStr
+ ", dir:"
+ dir.getLocation());
}
String byteOrder = properties.get("graph.byteOrder");
if (!byteOrder.equalsIgnoreCase("" + dir.getByteOrder()))
throw new IllegalStateException(
"Configured graph.byteOrder ("
+ dir.getByteOrder()
+ ") is not equal to loaded "
+ byteOrder
+ "");
String bytesForFlags = properties.get("graph.bytesForFlags");
if (!bytesForFlags.equalsIgnoreCase("" + encodingManager.getBytesForFlags()))
throw new IllegalStateException(
"Configured graph.bytesForFlags ("
+ encodingManager.getBytesForFlags()
+ ") is not equal to loaded "
+ bytesForFlags);
String dim = properties.get("graph.dimension");
baseGraph.loadExisting(dim);
for (CHGraphImpl cg : chGraphs) {
if (!cg.loadExisting()) throw new IllegalStateException("Cannot load " + cg);
}
return true;
}
return false;
}
@Test
public void testEnsureSize() {
Directory dir = new RAMDirectory();
graph = newGHStorage(dir, false).create(defaultSize);
int testIndex = dir.find("edges").getSegmentSize() * 3;
graph.edge(0, testIndex, 10, true);
// test if optimize works without error
graph.optimize();
}
@Override
public void close() throws IOException {
for (Directory delegate : distributor.all()) {
delegate.close();
}
synchronized (mutex) {
filesMetadata = ImmutableMap.of();
files = Strings.EMPTY_ARRAY;
}
}
public void close() throws IOException {
if (doClose) {
try {
secondaryDir.close();
} finally {
primaryDir.close();
}
doClose = false;
}
}
public static void main(String[] args) {
Directory directory = new Directory(new TextFile(), new AudioFile(), new ImageFile());
directory.setFilesInDir(new AudioFile(), new AudioFile(), new TextFile());
for (File f : directory.getFilesList()) {
System.out.println(f.getCurrentString());
}
}
/** Test closing locks twice */
public void testDoubleClose() throws IOException {
Path tempPath = createTempDir();
Directory dir = getDirectory(tempPath);
Lock l = dir.obtainLock("commit");
l.close();
l.close(); // close again, should be no exception
dir.close();
}
public void actionPerformed(ActionEvent e) {
int index = list.getSelectedIndex();
stopButton.setEnabled(false);
timers.get(index).cancel();
timers.remove(index);
startButton.setEnabled(true);
Directory task = directoryList.getDirectory(index);
task.backupNumber = 0;
log.setCaretPosition(log.getDocument().getLength());
}
private void doTest(Random random, PrintWriter out, boolean useCompoundFiles, int MAX_DOCS)
throws Exception {
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer(random);
IndexWriterConfig conf = newIndexWriterConfig(analyzer);
final MergePolicy mp = conf.getMergePolicy();
mp.setNoCFSRatio(useCompoundFiles ? 1.0 : 0.0);
IndexWriter writer = new IndexWriter(directory, conf);
if (VERBOSE) {
System.out.println("TEST: now build index MAX_DOCS=" + MAX_DOCS);
}
for (int j = 0; j < MAX_DOCS; j++) {
Document d = new Document();
d.add(newTextField(PRIORITY_FIELD, HIGH_PRIORITY, Field.Store.YES));
d.add(newTextField(ID_FIELD, Integer.toString(j), Field.Store.YES));
writer.addDocument(d);
}
writer.close();
// try a search without OR
IndexReader reader = DirectoryReader.open(directory);
IndexSearcher searcher = newSearcher(reader);
Query query = new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY));
out.println("Query: " + query.toString(PRIORITY_FIELD));
if (VERBOSE) {
System.out.println("TEST: search query=" + query);
}
final Sort sort = new Sort(SortField.FIELD_SCORE, new SortField(ID_FIELD, SortField.Type.INT));
ScoreDoc[] hits = searcher.search(query, null, MAX_DOCS, sort).scoreDocs;
printHits(out, hits, searcher);
checkHits(hits, MAX_DOCS, searcher);
// try a new search with OR
searcher = newSearcher(reader);
hits = null;
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.add(
new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY)), BooleanClause.Occur.SHOULD);
booleanQuery.add(
new TermQuery(new Term(PRIORITY_FIELD, MED_PRIORITY)), BooleanClause.Occur.SHOULD);
out.println("Query: " + booleanQuery.toString(PRIORITY_FIELD));
hits = searcher.search(booleanQuery, null, MAX_DOCS, sort).scoreDocs;
printHits(out, hits, searcher);
checkHits(hits, MAX_DOCS, searcher);
reader.close();
directory.close();
}
public void assertDeleteContent(Store store, DirectoryService service) throws IOException {
store.deleteContent();
assertThat(
Arrays.toString(store.directory().listAll()),
store.directory().listAll().length,
equalTo(0));
assertThat(store.stats().sizeInBytes(), equalTo(0l));
for (Directory dir : service.build()) {
assertThat(dir.listAll().length, equalTo(0));
}
}
