Issue while creating Vertex Centric Index on edge property.

[dxtr-1-0]

Janusgraph version => 0.6.1
Tinkerpop version =>3.5.1
Usign Janusgraph in the embedded library mode and not in server mode.

I am trying to create vertex centric index(es) on existing edge properties.
To start with I followed the steps in the documentation. With that I was getting the infamous issue of index getting stuck in INSTALLED state while waiting for it to get available (REGISTERED). On debugging it seemed like it was happening because of already open transactions at the time of waiting for the index to become available. As mentioned in several answers to similar problems online, I followed the steps to close open transactions before calling the ManagementSystem,awaitRelationIndexStatus method. This solved for the issue of index getting stuck in INSTALLED and now i am able to build edge index and REINDEX it. But the probelm is that since its closing all open transactions whatever operations are going on at the time of this indexing, will be aborted and might result in data loss. Please find below the code that i am using currently:

public void registerVertexCentricIndexOnEdgeProperty(String edgeLabel, String propertyName, String userId) throws MinervaException {
    String indexName = autoCreatedRelationIndexName(edgeLabel, propertyName);
    StandardJanusGraph standardJanusGraph = (StandardJanusGraph) getGraphObjectByName();
    JanusGraphManagement management = getManagementForGraph();
    val propertyKey = management.getPropertyKey(propertyName);
    val label = management.getEdgeLabel(edgeLabel);
    val index = management.buildEdgeIndex(label, indexName, Direction.BOTH, propertyKey);
    log.info("Created Edge Index: {}. Now Going to wait for it to become REGISTERED", index.name());
    management.commit();

    //Close all open transactions
    standardJanusGraph.getOpenTransactions().forEach(JanusGraphTransaction::rollback);
    ManagementSystem
            .awaitRelationIndexStatus(
                    standardJanusGraph,
                    indexName,
                    edgeLabel
            ).call();
    management = getManagementForGraph();
    management.updateIndex(management.getRelationIndex(label, indexName), SchemaAction.REINDEX).get();
    management.commit();
}

Is there a cleaner and more graceful way to do this? I tried searching for similar issue but everywhere the solutions mention the closing of transactions as a mandatory step but if that is the case then this seems like a bug as the official documentation does not mention it explicitly anywhere. Moreover, it essentially means that you have to stop reads and writes on graph while doing reindexing which itself can take sometime to finish. Any help is appreciated.

[UPDATE] :
I am trying to debug this locally using test cases in Java. In my case there are no ghost management instances (checked using mgmt.getOpenInstances()). There is only 1 open management instance which has the (current) suffix. Although, i see 4 open transactions using standardJanusGraph.getOpenTransaction(), and on closing them (as in the code above), i am able to move the index from INSTALLED to REGISTERED. I am unable to figure out whether these transactions are management transactions or normal graph transactions.

[FlorianHockmann]

I tried searching for similar issue but everywhere the solutions mention the closing of transactions as a mandatory step but if that is the case then this seems like a bug as the official documentation does not mention it explicitly anywhere.

I think it is mentioned there, but not very prominent and also not very descriptive. The code listing in the indexing chapter start with:

graph.tx().rollback() //Never create new indexes while a transaction is active

We should probably mention that this also means that all other JanusGraph instances should be stopped before as otherwise another instance could create a new transaction in parallel. I created an issue specifically for this: #3974.
If you want, you can of course try to create a PR for this yourself :)

Not sure how much it helps you, but if you can somehow avoid the need for reindexing in the first place, then you save yourself a lot of trouble. So, I'd always try to create all indexes directly in the same management transaction in which new vertex labels or property keys are created as JanusGraph can then directly enable the index.
I know that this isn't possible sometimes as you cannot foresee all needs for an index. Just wanted to mention it in case you aren't aware of this.

[dxtr-1-0]

Thanks for the response @FlorianHockmann
From the context gathered from discussions and replies, what i understand is that it is necessary to close all stale management transactions or ghost management instances before trying to register an index or more specifically before calling:

ManagementSystem
            .awaitRelationIndexStatus(
                    standardJanusGraph,
                    indexName,
                    edgeLabel
            ).call();

However, in my case, when i am checking management.getOpenInstances(), i get only 1 management instance which is the current one. However, I get 4 odd ongoing transactions at the point where I am executing the above line of code. I am unsure how to identify these transactions as management transaction or normal janusgraph operation transaction. I can afford closing all management transactions and even blocking all management transactions on other JanusGraph instances, but what I want to avoid is closing all normal transactions which eventually aborts all the reads and writes happening on the graph. 2 questions on that note:

1. Is it possible to rollback only management transactions and let the normal transactions run?
2. When you say no other JanusGraph instance should be running in parallel, do you essentially mean that if its a multi-node setup, graphs on all other nodes should be closed (more simply the instances brought down) and then we should proceed with reindexing? Or does it mean that only management instances need to be closed on all other nodes and normal transactions can keep on running?

[FlorianHockmann]

Let me try to summarize my understanding of this:

• Only management transactions have to be closed before executing such an index operation.
• Every JanusGraph instance (like a running JanusGraph Server) creates a management transaction to participate in schema changes.
• Since JanusGraph needs this management transaction to get notified about schema changes, JanusGraph instances should be completely shut down before performing an index operation.

This leads me to the following steps for index operations:

1. Stop all JanusGraph instances (e.g., by stopping all JanusGraph Server instances)
2. Close all management transactions in case there are still some open
3. Execute the index operation
4. Start JanusGraph instances again

So, yes, I think you have to stop all reads and writes to the graph happening during that time.

I'm not 100% sure though whether others agree that this is actually the recommended approach. @porunov (and others): Would you agree with this approach?
In that case, I'll add it to the description in #3974 so we can get it added to the docs.