@RequestMapping(value = "/single/{time}", method = RequestMethod.GET)
@ResponseBody
public JsonNode getInstant(
@PathVariable long time,
@RequestParam(required = false) String resolution,
@RequestParam(required = false) String timezone) {
TimeInstant timeInstant =
TimeInstant.fromValueObject(new TimeInstantVO(time, resolution, timezone));
long id;
try (Transaction tx = database.beginTx()) {
id = timeTree.getOrCreateInstant(timeInstant).getId();
tx.success();
}
JsonNode result;
try (Transaction tx = database.beginTx()) {
result = new JsonNode(database.getNodeById(id));
tx.success();
}
return result;
}
private long createDb() {
GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH);
long firstNodeId = -1;
Transaction tx = graphDb.beginTx();
try {
Node firstNode = graphDb.createNode();
firstNodeId = firstNode.getId();
firstNode.setProperty("message", "Hello, ");
firstNode.setProperty(
"someJson", "{\n \"is\" : \"vcard\",\n \"name\" : \"Jim Barritt\"\n}");
Node secondNode = graphDb.createNode();
secondNode.setProperty("message", "World!");
Relationship relationship = firstNode.createRelationshipTo(secondNode, KNOWS);
relationship.setProperty("message", "brave Neo4j ");
tx.success();
return firstNodeId;
} finally {
tx.finish();
graphDb.shutdown();
}
}
/**
* Removes all nodes with non-valid resource classes from the graph.
*
* @param docGraph
* @param validResourceClasses
*/
private void preProcessGraph(DocGraph docGraph, Set<String> validResourceClasses) {
log.info(String.format("Preprocessing DocGraph[%d]", docGraph.getId()));
Node n;
int cnt = 0;
try (Transaction tx = graphDB.beginTx()) {
for (Long nodeId : docGraph.getNodes()) {
n = graphDB.getNodeById(nodeId);
// node's class is resource class and it's not in the valid set
if (n.hasProperty(Constants.NODE_SUPER_CLASS_KEY)
&& n.getProperty(Constants.NODE_SUPER_CLASS_KEY)
.equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)
&& !validResourceClasses.contains(getNodeClass(n))) {
try (Transaction innerTx = graphDB.beginTx()) {
log.info("Deleting " + n);
for (Relationship e : n.getRelationships()) {
e.delete();
}
n.delete();
innerTx.success();
cnt++;
}
}
}
tx.success();
}
log.info(
String.format("Preprocessing removed %d nodes from DocGraph[%d]", cnt, docGraph.getId()));
}
@Override
public WeightedPath findSinglePath(Node start, Node end) {
lastMetadata = new Metadata();
AStarIterator iterator = new AStarIterator(start, end);
while (iterator.hasNext()) {
Node node = iterator.next();
GraphDatabaseService graphDb = node.getGraphDatabase();
if (node.equals(end)) {
// Hit, return path
double weight = iterator.visitData.get(node.getId()).wayLength;
LinkedList<Relationship> rels = new LinkedList<Relationship>();
Relationship rel =
graphDb.getRelationshipById(iterator.visitData.get(node.getId()).cameFromRelationship);
while (rel != null) {
rels.addFirst(rel);
node = rel.getOtherNode(node);
long nextRelId = iterator.visitData.get(node.getId()).cameFromRelationship;
rel = nextRelId == -1 ? null : graphDb.getRelationshipById(nextRelId);
}
Path path = toPath(start, rels);
lastMetadata.paths++;
return new WeightedPathImpl(weight, path);
}
}
return null;
}
public void run(GraphDatabaseService graphDb) {
timerOff(MAIN_TIMER);
Transaction tx = graphDb.beginTx();
try {
this.container = createContainer(graphDb);
tx.success();
} finally {
tx.finish();
}
timerOn(MAIN_TIMER);
tx = graphDb.beginTx();
try {
int max = getNumberOfIterations();
Object propertyValue = getPropertyValue();
if (getPropertyValue().getClass().isArray()) {
int arraySize = Array.getLength(getPropertyValue());
max /= arraySize;
}
for (int i = 0; i < max; i++) {
container.setProperty("my_key", propertyValue);
}
tx.success();
} finally {
tx.finish();
}
container = null;
}
@Test
public void modulesShouldBeDelegatedToInCorrectOrder() throws InterruptedException {
GraphDatabaseService database =
builder()
.setConfig(
"com.graphaware.module.test1.1",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
"com.graphaware.module.test3.3",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
"com.graphaware.module.test2.2",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.newGraphDatabase();
registerShutdownHook(database);
try (Transaction tx = database.beginTx()) {
database.createNode();
tx.success();
}
assertEquals(3, TEST_RUNTIME_MODULES.size());
assertEquals("test1", TEST_RUNTIME_MODULES.get(0).getId());
assertEquals("test2", TEST_RUNTIME_MODULES.get(1).getId());
assertEquals("test3", TEST_RUNTIME_MODULES.get(2).getId());
}
public void copyStore(StoreCopyRequester requester, CancellationRequest cancellationRequest)
throws IOException {
// Clear up the current temp directory if there
File storeDir = config.get(InternalAbstractGraphDatabase.Configuration.store_dir);
File tempStore = new File(storeDir, TEMP_COPY_DIRECTORY_NAME);
cleanDirectory(tempStore);
// Request store files and transactions that will need recovery
try (Response response =
requester.copyStore(decorateWithProgressIndicator(new ToFileStoreWriter(tempStore)))) {
// Update highest archived log id
// Write transactions that happened during the copy to the currently active logical log
writeTransactionsToActiveLogFile(tempStore, response);
} finally {
requester.done();
}
// This is a good place to check if the switch has been cancelled
checkCancellation(cancellationRequest, tempStore);
// Run recovery, so that the transactions we just wrote into the active log will be applied.
GraphDatabaseService graphDatabaseService = newTempDatabase(tempStore);
graphDatabaseService.shutdown();
// This is a good place to check if the switch has been cancelled
checkCancellation(cancellationRequest, tempStore);
// All is well, move the streamed files to the real store directory
for (File candidate : tempStore.listFiles(STORE_FILE_FILTER)) {
FileUtils.moveFileToDirectory(candidate, storeDir);
}
}
@Test
public void shouldBeAbleToImplementAnonymousGraphQuery() throws Exception {
// given
GraphDatabaseService db = Db.impermanentDb();
Transaction tx = db.beginTx();
Node firstNode = db.createNode();
Node secondNode = db.createNode();
firstNode.createRelationshipTo(secondNode, withName("CONNECTED_TO"));
tx.success();
tx.finish();
GraphQuery query =
new GraphQuery() {
@Override
public Iterable<Node> execute(Node startNode) {
return startNode.traverse(
Traverser.Order.DEPTH_FIRST,
StopEvaluator.DEPTH_ONE,
ReturnableEvaluator.ALL_BUT_START_NODE,
withName("CONNECTED_TO"),
Direction.OUTGOING);
}
};
// when
Iterable<Node> result = query.execute(firstNode);
// then
Iterator<Node> iterator = result.iterator();
assertEquals(secondNode, iterator.next());
assertFalse(iterator.hasNext());
}
public OnlineBackup full(String targetDirectory, boolean verification) {
if (directoryContainsDb(targetDirectory)) {
throw new RuntimeException(targetDirectory + " already contains a database");
}
BackupClient client =
new BackupClient(hostNameOrIp, port, StringLogger.DEV_NULL, Client.NO_STORE_ID_GETTER);
try {
Response<Void> response = client.fullBackup(new ToFileStoreWriter(targetDirectory));
GraphDatabaseService targetDb =
startTemporaryDb(targetDirectory, VerificationLevel.NONE /* run full check instead */);
try {
unpackResponse(response, targetDb, MasterUtil.txHandlerForFullCopy());
} finally {
targetDb.shutdown();
}
if (verification) {
StoreAccess newStore = new StoreAccess(targetDirectory);
try {
ConsistencyCheck.run(newStore, false);
} finally {
newStore.close();
}
}
} finally {
client.shutdown();
}
return this;
}
@Test
public void shouldMigrate() throws IOException, ConsistencyCheckIncompleteException {
// WHEN
upgrader(new StoreMigrator(monitor, fs)).migrateIfNeeded(find20FormatStoreDirectory(storeDir));
// THEN
assertEquals(100, monitor.eventSize());
assertTrue(monitor.isStarted());
assertTrue(monitor.isFinished());
GraphDatabaseService database =
cleanup.add(new GraphDatabaseFactory().newEmbeddedDatabase(storeDir.getAbsolutePath()));
try {
DatabaseContentVerifier verifier = new DatabaseContentVerifier(database);
verifier.verifyNodes(501);
verifier.verifyRelationships(500);
verifier.verifyNodeIdsReused();
verifier.verifyRelationshipIdsReused();
verifier.verifyLegacyIndex();
verifier.verifyIndex();
} finally {
// CLEANUP
database.shutdown();
}
NeoStore neoStore = cleanup.add(storeFactory.newNeoStore(false));
verifyNeoStore(neoStore);
neoStore.close();
assertConsistentStore(storeDir);
}
@Override
/**
* Cleanup any state for this DB. Called once per DB instance; there is one DB instance per client
* thread.
*/
public void cleanup() throws DBException {
try {
if (mode == Mode.EMBEDDED) {
synchronized (LOCK) {
instances--;
if (instances == 0) {
GDS.shutdown();
System.out.println("neo4j connection closed with @" + GDS);
}
}
} else {
gds.shutdown();
System.out.println("neo4j connection closed with @" + gds);
}
} catch (Exception e1) {
System.err.println("Could not close MongoDB connection pool: " + e1.toString());
e1.printStackTrace();
return;
}
}
@Override
public void persistModel() throws IOException, XMLStreamException {
try (Transaction tx = graphDb.beginTx()) {
final ProgressReporter reporter = new ProgressReporter(null, null);
final StringWriter writer = new StringWriter();
final XmlGraphMLWriter xmlGraphMLWriter = new XmlGraphMLWriter();
final Config config = Config.config();
xmlGraphMLWriter.write(new DatabaseSubGraph(graphDb), writer, reporter, config.withTypes());
tx.success();
final String fileName = generatorConfig.getModelPathNameWithoutExtension() + ".graphml";
String graphmlContent = writer.toString();
// this is required to be compatibile with OrientDB
graphmlContent =
graphmlContent.replaceAll(
"<graph id=\"G\" edgedefault=\"directed\">",
"<graph id=\"G\" edgedefault=\"directed\">\n<key id=\"labels\" for=\"node\" attr.name=\"labels\" attr.type=\"string\"/>");
FileUtils.writeStringToFile(new File(fileName), graphmlContent.trim());
} finally {
graphDb.shutdown();
// cleanup: delete the database directory
if (new File(databasePath).exists()) {
FileUtils.deleteDirectory(new File(databasePath));
}
}
}
@Test
public void shouldBeAbleToAccessExceptionThrownInEventHook() {
class MyFancyException extends Exception {}
ExceptionThrowingEventHandler handler =
new ExceptionThrowingEventHandler(new MyFancyException(), null, null);
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler(handler);
try {
Transaction tx = db.beginTx();
try {
db.createNode().delete();
tx.success();
tx.close();
fail("Should fail commit");
} catch (TransactionFailureException e) {
Throwable currentEx = e;
do {
currentEx = currentEx.getCause();
if (currentEx instanceof MyFancyException) {
return;
}
} while (currentEx.getCause() != null);
fail(
"Expected to find the exception thrown in the event hook as the cause of transaction failure.");
}
} finally {
db.unregisterTransactionEventHandler(handler);
}
}
@RequestMapping(value = "/range/{startTime}/{endTime}", method = RequestMethod.GET)
@ResponseBody
public JsonNode[] getInstants(
@PathVariable long startTime,
@PathVariable long endTime,
@RequestParam(required = false) String resolution,
@RequestParam(required = false) String timezone) {
TimeInstant startTimeInstant =
TimeInstant.fromValueObject(new TimeInstantVO(startTime, resolution, timezone));
TimeInstant endTimeInstant =
TimeInstant.fromValueObject(new TimeInstantVO(endTime, resolution, timezone));
List<Node> nodes;
try (Transaction tx = database.beginTx()) {
nodes = timeTree.getOrCreateInstants(startTimeInstant, endTimeInstant);
tx.success();
}
JsonNode[] result;
try (Transaction tx = database.beginTx()) {
result = jsonNodes(nodes);
tx.success();
}
return result;
}
@Test
public void moduleShouldBeInitializedWhenRuntimeIsEnabledWithoutAnyTransactions()
throws InterruptedException {
GraphDatabaseService database =
builder()
.setConfig(
TestModuleBootstrapper.MODULE_ENABLED,
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
TestModuleBootstrapper.MODULE_CONFIG,
TestModuleBootstrapper.MODULE_CONFIG.getDefaultValue())
.newGraphDatabase();
registerShutdownHook(database);
Thread.sleep(1000);
assertEquals(1, TEST_RUNTIME_MODULES.size());
assertTrue(TEST_RUNTIME_MODULES.get(0).isInitialized());
assertEquals("configValue", TEST_RUNTIME_MODULES.get(0).getConfig().get("configKey"));
database.shutdown();
assertFalse(TEST_RUNTIME_MODULES.get(0).isInitialized());
}
@Test
public void testRemoveReferenceNode() throws Exception {
GraphDatabaseService db = new ImpermanentGraphDatabase();
final GraphDatabaseShellServer server = new GraphDatabaseShellServer(db, false);
ShellClient client = new SameJvmClient(server);
Documenter doc = new Documenter("sample session", client);
doc.add("pwd", "", "where are we?");
doc.add("set name \"Jon\"", "", "On the current node, set the key \"name\" to value \"Jon\"");
doc.add("start n=node(0) return n", "Jon", "send a cypher query");
doc.add(
"mkrel -c -d i -t LIKES --np \"{'app':'foobar'}\"",
"",
"make an incoming relationship of type LIKES, create the end node with the node properties specified.");
doc.add("ls", "1", "where are we?");
doc.add("cd 1", "", "change to the newly created node");
doc.add("ls -avr", "LIKES", "list relationships, including relationshship id");
doc.add(
"mkrel -c -d i -t KNOWS --np \"{'name':'Bob'}\"",
"",
"create one more KNOWS relationship and the end node");
doc.add("pwd", "0", "print current history stack");
doc.add("ls -avr", "KNOWS", "verbose list relationships");
doc.run();
// TODO: implement support for removing root node and previous nodes in the history stack of PWD
// client.getServer().interpretLine( "rmnode -f 0", client.session(), client.getOutput() );
// client.getServer().interpretLine( "cd", client.session(), client.getOutput() );
// client.getServer().interpretLine( "pwd", client.session(), client.getOutput() );
server.shutdown();
db.shutdown();
}
@Test
public void moduleShouldBeInitializedWhenAnotherModuleIsMisConfigured()
throws InterruptedException {
GraphDatabaseService database =
builder()
.setConfig("com.graphaware.module.wrong1.enabled", "com.not.existent.Bootstrapper")
.setConfig("com.graphaware.module.wrong2.2", "com.not.existent.Bootstrapper")
.setConfig(
TestModuleBootstrapper.MODULE_ENABLED,
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
TestModuleBootstrapper.MODULE_CONFIG,
TestModuleBootstrapper.MODULE_CONFIG.getDefaultValue())
.newGraphDatabase();
registerShutdownHook(database);
try (Transaction tx = database.beginTx()) {
database.createNode();
tx.success();
}
assertEquals(1, TEST_RUNTIME_MODULES.size());
assertTrue(TEST_RUNTIME_MODULES.get(0).isInitialized());
assertEquals("configValue", TEST_RUNTIME_MODULES.get(0).getConfig().get("configKey"));
database.shutdown();
assertFalse(TEST_RUNTIME_MODULES.get(0).isInitialized());
}
@Override
public Map<String, Node> create(GraphDatabaseService graphdb) {
Map<String, Node> result = new HashMap<String, Node>();
Transaction tx = graphdb.beginTx();
try {
graphdb.index().getRelationshipAutoIndexer().setEnabled(autoIndexRelationships);
for (NODE def : nodes) {
result.put(
def.name(),
init(
graphdb.createNode(),
def.setNameProperty() ? def.name() : null,
def.properties(),
graphdb.index().getNodeAutoIndexer(),
autoIndexNodes));
}
for (REL def : rels) {
init(
result
.get(def.start())
.createRelationshipTo(
result.get(def.end()), DynamicRelationshipType.withName(def.type())),
def.setNameProperty() ? def.name() : null,
def.properties(),
graphdb.index().getRelationshipAutoIndexer(),
autoIndexRelationships);
}
tx.success();
} finally {
tx.finish();
}
return result;
}
@Test
public void modulesShouldBeDelegatedToInRandomOrderWhenOrderClashes()
throws InterruptedException {
GraphDatabaseService database =
builder()
.setConfig(
"com.graphaware.module.test1.1",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
"com.graphaware.module.test3.1",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
"com.graphaware.module.test2.1",
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.newGraphDatabase();
registerShutdownHook(database);
try (Transaction tx = database.beginTx()) {
database.createNode();
tx.success();
}
assertEquals(3, TEST_RUNTIME_MODULES.size());
Set<String> remaining = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
assertTrue(remaining.remove(TEST_RUNTIME_MODULES.get(0).getId()));
assertTrue(remaining.remove(TEST_RUNTIME_MODULES.get(1).getId()));
assertTrue(remaining.remove(TEST_RUNTIME_MODULES.get(2).getId()));
assertTrue(remaining.isEmpty());
}
/** {@inheritDoc} */
@Override
protected Relationship create(GraphDatabaseService database) {
return database
.getNodeById(startNodeGraphId)
.createRelationshipTo(
database.getNodeById(endNodeGraphId), DynamicRelationshipType.withName(type));
}
@Test
public void testFindByIdFound() {
// Arrange
//
String id = "ABCDEF";
SubscriptionExpiry expiry = SubscriptionExpiry.NEVER;
Subscription expected = Subscription.builder().id(id).expiry(expiry).build();
when(mock_node.getProperty(eq(Subscription.PROP_ID))).thenReturn(expected.id());
when(mock_node.getProperty(eq(Subscription.PROP_EXPIRY)))
.thenReturn(expected.expiry().toString());
when(mock_db.beginTx()).thenReturn(mock_tx);
when(mock_db.findNode(eq(label), eq(Subscription.PROP_ID), eq(expected.id())))
.thenReturn(mock_node);
// Act
//
Subscription subs = s_dao.findById(id);
// Assert
//
assertNotNull(subs);
assertTrue(expected.equals(subs));
verify(mock_db, atLeastOnce()).beginTx();
verify(mock_db, times(1)).findNode(any(), any(), any());
verify(mock_tx, atLeastOnce()).success();
verify(mock_tx, times(1)).close();
}
public static int getDocumentSizeForFeature(GraphDatabaseService db, Long id) {
int documentSize;
String cacheKey = "DOCUMENT_SIZE_FEATURE_" + id;
if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) {
Node startNode = db.getNodeById(id);
Iterator<Node> classes =
db.traversalDescription()
.depthFirst()
.relationships(withName("HAS_CLASS"), Direction.OUTGOING)
.evaluator(Evaluators.fromDepth(1))
.evaluator(Evaluators.toDepth(1))
.traverse(startNode)
.nodes()
.iterator();
documentSize = IteratorUtil.count(classes);
vectorSpaceModelCache.put(cacheKey, documentSize);
} else {
documentSize = (Integer) vectorSpaceModelCache.getIfPresent(cacheKey);
}
return documentSize;
}
@Test
public void clearGraphWithoutRuntimeShouldDeleteBasedOnRelInclusionPolicy() {
try (Transaction tx = database.beginTx()) {
String cypher =
"CREATE "
+ "(purple:Purple {name:'Purple'})<-[:REL]-(red1:Red {name:'Red'})-[:REL]->(black1:Black {name:'Black'})-[:REL]->(green:Green {name:'Green'}),"
+ "(red2:Red {name:'Red'})-[:REL]->(black2:Black {name:'Black'}), (blue1:Blue)-[:REL2]->(blue2:Blue)";
populateDatabase(cypher);
tx.success();
}
InclusionPolicies inclusionPolicies =
InclusionPolicies.all().with(new BlueNodeInclusionPolicy()).with(new Rel2InclusionPolicy());
try (Transaction tx = database.beginTx()) {
clearGraph(database, inclusionPolicies);
tx.success();
}
try (Transaction tx = database.beginTx()) {
assertEquals(6, count(at(database).getAllNodes()));
assertEquals(4, count(at(database).getAllRelationships()));
tx.success();
}
}
private static List<Double> getWeightVectorForClass(
Map<String, List<LinkedHashMap<String, Object>>> documents,
String key,
List<Integer> featureIndexList,
GraphDatabaseService db) {
List<Double> weightVector;
Transaction tx = db.beginTx();
// Get class id
Long classId =
db.findNodesByLabelAndProperty(DynamicLabel.label("Class"), "name", key)
.iterator()
.next()
.getId();
// Get weight vector for class
List<Long> longs =
documents
.get(key)
.stream()
.map(a -> ((Integer) a.get("feature")).longValue())
.collect(Collectors.toList());
weightVector =
featureIndexList
.stream()
.map(i -> longs.contains(i.longValue()) ? tfidf(db, i.longValue(), classId) : 0.0)
.collect(Collectors.toList());
tx.success();
tx.close();
return weightVector;
}
@Test
public void testUpdateNode() {
double lon = -139.12;
double lat = -45.24;
Transaction tx = graphDb.beginTx();
String query = "MATCH n-[r]-() DELETE n, r";
graphDb.execute(query);
query = "MATCH (n) WHERE HAS (n.geohash) DELETE n";
graphDb.execute(query);
root = PrefixTree.getOrCreateRoot(INDEXLABEL, graphDb);
List<Node> candidate = gendata.insertNode(graphDb, 10, true);
for (Node node : candidate) {
PrefixTree.addNode(graphDb, root, node);
}
String geoHashPre = (String) candidate.get(0).getProperty(GEOHASH);
String geoHashCur = GeoHash.getHash(lon, lat);
List<Node> child = PrefixTree.getChild(geoHashPre, root, 7);
assertEquals(child.size(), 1);
PrefixTree.updateNode(graphDb, root, candidate.get(0), lon, lat);
child = PrefixTree.getChild(geoHashPre, root, 7);
assertEquals(child.size(), 0);
child = PrefixTree.getChild(geoHashCur, root, 7);
assertEquals(child.size(), 1);
tx.close();
graphDb.shutdown();
}
public static Map<Long, Integer> getTermFrequencyMapForDocument(
GraphDatabaseService db, Long classId) {
Map<Long, Integer> termDocumentMatrix;
String cacheKey = "TERM_DOCUMENT_FREQUENCY_" + classId;
if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) {
Node classNode = db.getNodeById(classId);
termDocumentMatrix = new HashMap<>();
IteratorUtil.asCollection(
db.traversalDescription()
.depthFirst()
.relationships(withName("HAS_CLASS"), Direction.INCOMING)
.evaluator(Evaluators.fromDepth(1))
.evaluator(Evaluators.toDepth(1))
.traverse(classNode))
.stream()
.forEach(
p ->
termDocumentMatrix.put(
p.endNode().getId(), (Integer) p.lastRelationship().getProperty("matches")));
vectorSpaceModelCache.put(cacheKey, termDocumentMatrix);
} else {
termDocumentMatrix = (Map<Long, Integer>) vectorSpaceModelCache.getIfPresent(cacheKey);
}
return termDocumentMatrix;
}
@Test
public void removeNodesWithARelation() {
int originalNodeCount = countNodesOf(graphDb);
int removedNodeCount = 0;
Transaction tx = graphDb.beginTx();
try {
Set<Node> toRemove = new HashSet<Node>();
for (Node node : graphDb.getAllNodes()) {
for (Relationship relationship : node.getRelationships(RelationType.ON)) {
toRemove.add(relationship.getStartNode());
toRemove.add(relationship.getEndNode());
relationship.delete();
}
}
for (Node node : toRemove) {
node.delete();
removedNodeCount++;
}
tx.success();
} finally {
tx.finish();
}
int finalNodeCount = countNodesOf(graphDb);
assertEquals(
Integer.valueOf(originalNodeCount), Integer.valueOf(finalNodeCount + removedNodeCount));
}
@Test
public void moduleShouldBeInitializedWhenRuntimeIsEnabled() throws InterruptedException {
GraphDatabaseService database =
builder()
.setConfig(
TestModuleBootstrapper.MODULE_ENABLED,
TestModuleBootstrapper.MODULE_ENABLED.getDefaultValue())
.setConfig(
TestModuleBootstrapper.MODULE_CONFIG,
TestModuleBootstrapper.MODULE_CONFIG.getDefaultValue())
.newGraphDatabase();
registerShutdownHook(database);
try (Transaction tx = database.beginTx()) {
database.createNode(); // tx just to kick off Runtime init
tx.success();
}
assertEquals(1, TEST_RUNTIME_MODULES.size());
assertTrue(TEST_RUNTIME_MODULES.get(0).isInitialized());
assertEquals("configValue", TEST_RUNTIME_MODULES.get(0).getConfig().get("configKey"));
database.shutdown();
assertFalse(TEST_RUNTIME_MODULES.get(0).isInitialized());
}
public void rn() throws IOException {
List<RoadLink> links = loadToDatabase("/Users/duduba/gj.mif", "/Users/duduba/gj.mid", false);
GraphDatabaseService graphDb = neo.getDb();
Index<Node> nodeIndex = neo.getNodeIndex();
for (RoadLink link : links) {
Transaction tx = graphDb.beginTx();
try {
Node fromNode = nodeIndex.get("id", link.fromNode).getSingle();
if (fromNode == null) {
fromNode = graphDb.createNode();
fromNode.setProperty("id", link.fromNode);
nodeIndex.add(fromNode, "id", link.fromNode);
}
Node toNode = nodeIndex.get("id", link.toNode).getSingle();
if (toNode == null) {
toNode = graphDb.createNode();
toNode.setProperty("id", link.toNode);
nodeIndex.add(toNode, "id", link.toNode);
}
Relationship r = fromNode.createRelationshipTo(toNode, Neo.RelTypes.TO);
r.setProperty("no", link.no);
r.setProperty("name", link.name);
tx.success();
} finally {
tx.finish();
}
}
logger.debug("haha, it's ok!");
}
/**
* Tests an issue where loading all relationship types and property indexes after the neostore
* data source had been started internally. The db would be in a state where it would need
* recovery for the neostore data source, as well as some other data source. This would fail since
* eventually TxManager#getTransaction() would be called, which would fail since it hadn't as of
* yet recovered fully. Whereas that failure would happen in a listener and merely be logged, one
* effect of it would be that there would seem to be no relationship types in the database.
*/
@Test
public void recoverNeoAndIndexHavingAllRelationshipTypesAfterRecovery() throws Exception {
// Given (create transactions and kill process, leaving it needing for recovery)
deleteRecursively(new File(dir));
assertEquals(
0,
getRuntime()
.exec(
new String[] {
"java",
"-Djava.awt.headless=true",
"-cp",
getProperty("java.class.path"),
getClass().getName()
})
.waitFor());
// When
GraphDatabaseService db = new TestGraphDatabaseFactory().newEmbeddedDatabase(dir);
// Then
try (Transaction ignored = db.beginTx()) {
assertEquals(
MyRelTypes.TEST.name(),
GlobalGraphOperations.at(db).getAllRelationshipTypes().iterator().next().name());
} finally {
db.shutdown();
}
}