Examples with LockTuple org.janusgraph.graphdb.transaction.lock.LockTuple used on opensource projects

Example 1 with LockTuple

use of org.janusgraph.graphdb.transaction.lock.LockTuple in project janusgraph by JanusGraph.

the class StandardJanusGraphTx method getLock.

private TransactionLock getLock(final LockTuple la) {
    if (config.isSingleThreaded())
        return FakeLock.INSTANCE;
    Map<LockTuple, TransactionLock> result = uniqueLocks;
    if (result == UNINITIALIZED_LOCKS) {
        Preconditions.checkArgument(!config.isSingleThreaded());
        synchronized (this) {
            result = uniqueLocks;
            if (result == UNINITIALIZED_LOCKS)
                uniqueLocks = result = new ConcurrentHashMap<>();
        }
    }
    // TODO: clean out no longer used locks from uniqueLocks when it grows to large (use ReadWriteLock to protect against race conditions)
    TransactionLock lock = new ReentrantTransactionLock();
    TransactionLock existingLock = result.putIfAbsent(la, lock);
    return (existingLock == null) ? lock : existingLock;
}

Example 2 with LockTuple

use of org.janusgraph.graphdb.transaction.lock.LockTuple in project janusgraph by JanusGraph.

the class StandardJanusGraphTx method addProperty.

public JanusGraphVertexProperty addProperty(VertexProperty.Cardinality cardinality, JanusGraphVertex vertex, PropertyKey key, Object value, Long id) {
    if (key.cardinality().convert() != cardinality && cardinality != VertexProperty.Cardinality.single)
        throw new SchemaViolationException("Key is defined for %s cardinality which conflicts with specified: %s", key.cardinality(), cardinality);
    verifyWriteAccess(vertex);
    Preconditions.checkArgument(!(key instanceof ImplicitKey), "Cannot create a property of implicit type: %s", key.name());
    vertex = ((InternalVertex) vertex).it();
    Preconditions.checkNotNull(key);
    checkPropertyConstraintForVertexOrCreatePropertyConstraint(vertex, key);
    final Object normalizedValue = verifyAttribute(key, value);
    Cardinality keyCardinality = key.cardinality();
    // Determine unique indexes
    final List<IndexLockTuple> uniqueIndexTuples = new ArrayList<>();
    for (CompositeIndexType index : TypeUtil.getUniqueIndexes(key)) {
        IndexSerializer.IndexRecords matches = IndexSerializer.indexMatches(vertex, index, key, normalizedValue);
        for (Object[] match : matches.getRecordValues()) uniqueIndexTuples.add(new IndexLockTuple(index, match));
    }
    TransactionLock uniqueLock = getUniquenessLock(vertex, (InternalRelationType) key, normalizedValue);
    // Add locks for unique indexes
    for (IndexLockTuple lockTuple : uniqueIndexTuples) uniqueLock = new CombinerLock(uniqueLock, getLock(lockTuple), times);
    uniqueLock.lock(LOCK_TIMEOUT);
    try {
        // //Check vertex-centric uniqueness -> this doesn't really make sense to check
        // if (config.hasVerifyUniqueness()) {
        // if (cardinality == Cardinality.SINGLE) {
        // if (!Iterables.isEmpty(query(vertex).type(key).properties()))
        // throw new SchemaViolationException("A property with the given key [%s] already exists on the vertex [%s] and the property key is defined as single-valued", key.name(), vertex);
        // }
        // if (cardinality == Cardinality.SET) {
        // if (!Iterables.isEmpty(Iterables.filter(query(vertex).type(key).properties(), new Predicate<JanusGraphVertexProperty>() {
        // @Override
        // public boolean apply(@Nullable JanusGraphVertexProperty janusgraphProperty) {
        // return normalizedValue.equals(janusgraphProperty.value());
        // }
        // })))
        // throw new SchemaViolationException("A property with the given key [%s] and value [%s] already exists on the vertex and the property key is defined as set-valued", key.name(), normalizedValue);
        // }
        // }
        long propId = id == null ? IDManager.getTemporaryRelationID(temporaryIds.nextID()) : id;
        StandardVertexProperty prop = new StandardVertexProperty(propId, key, (InternalVertex) vertex, normalizedValue, ElementLifeCycle.New);
        if (config.hasAssignIDsImmediately() && id == null)
            graph.assignID(prop);
        // Delete properties if the cardinality is restricted
        if (cardinality == VertexProperty.Cardinality.single || cardinality == VertexProperty.Cardinality.set) {
            Consumer<JanusGraphVertexProperty> propertyRemover = JanusGraphVertexProperty.getRemover(cardinality, normalizedValue);
            if ((!config.hasVerifyUniqueness() || ((InternalRelationType) key).getConsistencyModifier() != ConsistencyModifier.LOCK) && !TypeUtil.hasAnyIndex(key) && cardinality == keyCardinality.convert()) {
                // Only delete in-memory so as to not trigger a read from the database which isn't necessary because we will overwrite blindly
                // We need to label the new property as "upsert", so that in case property deletion happens, we not only delete this new
                // in-memory property, but also read from database to delete the old value (if exists)
                ((InternalVertex) vertex).getAddedRelations(p -> p.getType().equals(key)).forEach(p -> propertyRemover.accept((JanusGraphVertexProperty) p));
                prop.setUpsert(true);
            } else {
                ((InternalVertex) vertex).query().types(key).properties().forEach(propertyRemover);
            }
        }
        // Check index uniqueness
        if (config.hasVerifyUniqueness()) {
            // Check all unique indexes
            for (IndexLockTuple lockTuple : uniqueIndexTuples) {
                if (!Iterables.isEmpty(IndexHelper.getQueryResults(lockTuple.getIndex(), lockTuple.getAll(), this)))
                    throw new SchemaViolationException("Adding this property for key [%s] and value [%s] violates a uniqueness constraint [%s]", key.name(), normalizedValue, lockTuple.getIndex());
            }
        }
        connectRelation(prop);
        return prop;
    } finally {
        uniqueLock.unlock();
    }
}