org.neo4j.procedure.impl.GlobalProceduresRegistry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-procedure Show documentation
Show all versions of neo4j-procedure Show documentation
Neo4j Community Procedures.
The newest version!
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see > builtin;
private final Path proceduresDirectory;
private final RegistrationUpdater updater = new RegistrationUpdater();
private final ProcedureJarLoader loader;
private final Predicate isReservedNamespace;
private static final AtomicLong SIGNATURE_VERSION_GENERATOR = new AtomicLong(0);
private final AtomicReference currentProcedureView =
new AtomicReference<>(makeSnapshot(registry, safeComponents, allComponents));
@VisibleForTesting
public GlobalProceduresRegistry() {
this(SpecialBuiltInProcedures.from("N/A", "N/A"), null, NullLog.getInstance(), ProcedureConfig.DEFAULT);
}
public GlobalProceduresRegistry(
Supplier> builtin,
Path proceduresDirectory,
InternalLog log,
ProcedureConfig config) {
this.builtin = builtin;
this.proceduresDirectory = proceduresDirectory;
this.typeCheckers = new TypeCheckers();
this.compiler = new ProcedureCompiler(typeCheckers, safeComponents, allComponents, log, config);
// We must not allow external sources to register procedures in the reserved namespaces.
// Thus, we restrict the allowed namespaces when loading from disk. The built-in procedure
// classes will be able to register in any namespace with the unrestricted compiler.
var restrictedCompiler = compiler.withAdditionalProcedureRestrictions(
NamingRestrictions.rejectReservedNamespace(config.reservedProcedureNamespaces()));
this.loader = new ProcedureJarLoader(restrictedCompiler, log, config.procedureReloadEnabled());
this.isReservedNamespace = Globbing.compose(config.reservedProcedureNamespaces(), List.of());
}
/**
* Register a new procedure.
* @param proc the procedure.
*/
@Override
public void register(CallableProcedure proc) throws ProcedureException {
try (var ignored = updater.acquire()) {
registry.register(proc);
}
}
/**
* Register a new function.
* @param function the function.
*/
@Override
public void register(CallableUserFunction function) throws ProcedureException {
try (var ignored = updater.acquire()) {
registry.register(function);
}
}
/**
* Register a new function.
* @param function the function.
*/
@Override
public void register(CallableUserAggregationFunction function) throws ProcedureException {
try (var ignored = updater.acquire()) {
registry.register(function);
}
}
/**
* Register a new internal procedure defined with annotations on a java class.
* @param proc the procedure class
*/
@Override
public void registerProcedure(Class proc) throws ProcedureException {
try (var ignored = updater.acquire()) {
for (var procedure : compiler.compileProcedure(proc, true)) {
registry.register(procedure);
}
}
}
/**
* Register a new function defined with annotations on a java class.
* @param func the function class
*/
@Override
public void registerFunction(Class func) throws ProcedureException {
try (var ignored = updater.acquire()) {
for (var function : compiler.compileFunction(func, false)) {
registry.register(function);
}
}
}
/**
* Register a new aggregation function defined with annotations on a java class.
* @param func the function class
*/
@Override
public void registerAggregationFunction(Class func) throws ProcedureException {
try (var ignored = updater.acquire()) {
for (var aggregation : compiler.compileAggregationFunction(func)) {
registry.register(aggregation);
}
}
}
/**
* Registers a type and its mapping to Neo4jTypes
*
* @param javaClass
* the class of the native type
* @param type
* the mapping to Neo4jTypes
*/
@Override
public void registerType(Class javaClass, Neo4jTypes.AnyType type) {
typeCheckers.registerType(javaClass, new TypeCheckers.DefaultValueConverter(type));
}
/**
* Registers a component, these become available in reflective procedures for injection.
* @param cls the type of component to be registered (this is what users 'ask' for in their field declaration)
* @param provider a function that supplies the component, given the context of a procedure invocation
* @param safe set to false if this component can bypass security, true if it respects security
*/
@Override
public void registerComponent(
Class cls, ThrowingFunction provider, boolean safe) {
try (var ignored = updater.acquire()) {
if (safe) {
safeComponents.register(cls, provider);
}
allComponents.register(cls, provider);
}
}
@Override
public ProcedureView getCurrentView() {
return currentProcedureView.getAcquire();
}
@Override
public void start() throws Exception {
try (var ignored = updater.acquire()) {
unguardedLoadFromDisk(registry, (name) -> true);
for (var procedure : builtin.get()) {
registry.register(procedure);
}
}
}
@Override
public LoadInformation reloadProceduresFromDisk(Transaction tx, Predicate shouldLoadNamespace)
throws IOException, KernelException {
try (var ignored = updater.acquireFromTransaction((InternalTransaction) tx)) {
Predicate shouldTombstone = (name) -> {
var str = name.toString();
return shouldLoadNamespace.test(str) && !isReservedNamespace.test(str);
};
// To avoid tainting the state in case of failure, we create an intermediate.
var culled = ProcedureRegistry.tombstone(registry, shouldTombstone);
var out = unguardedLoadFromDisk(culled, shouldLoadNamespace);
registry = culled;
return out;
}
}
private LoadInformation unguardedLoadFromDisk(ProcedureRegistry registry, Predicate shouldLoadNamespaces)
throws IOException, KernelException {
// We must not allow external sources to register procedures in the reserved namespaces.
// Thus, we restrict the allowed namespaces when loading from disk. The built-in procedure
// classes will be able to register in any namespace with the unrestricted compiler.
ProcedureJarLoader.Callables callables =
loader.loadProceduresFromDir(proceduresDirectory, shouldLoadNamespaces);
for (var procedure : callables.procedures()) {
registry.register(procedure);
}
for (var function : callables.functions()) {
registry.register(function);
}
for (var aggregation : callables.aggregationFunctions()) {
registry.register(aggregation);
}
return new LoadInformation(
callables.procedures().stream()
.map(CallableProcedure::signature)
.toList(),
callables.functions().stream()
.map(CallableUserFunction::signature)
.toList(),
callables.aggregationFunctions().stream()
.map(CallableUserAggregationFunction::signature)
.toList());
}
@Override
public void stop() throws Exception {
loader.close();
}
@VisibleForTesting
@Override
public void unregister(QualifiedName name) {
try (var ignored = updater.acquire()) {
registry.unregister(name);
}
}
public BulkRegistration bulk() {
return new BulkRegistration(updater.acquire());
}
public class BulkRegistration implements GlobalProcedures, Resource {
final Resource onClose;
private BulkRegistration(Resource onClose) {
this.onClose = onClose;
}
/**
* Register a new procedure.
* @param proc the procedure.
*/
@Override
public void register(CallableProcedure proc) throws ProcedureException {
registry.register(proc);
}
/**
* Register a new function.
* @param function the function.
*/
@Override
public void register(CallableUserFunction function) throws ProcedureException {
registry.register(function);
}
/**
* Register a new function.
* @param function the function.
*/
@Override
public void register(CallableUserAggregationFunction function) throws ProcedureException {
registry.register(function);
}
/**
* Register a new internal procedure defined with annotations on a java class.
* @param proc the procedure class
*/
@Override
public void registerProcedure(Class proc) throws ProcedureException {
for (var procedure : compiler.compileProcedure(proc, true)) {
registry.register(procedure);
}
}
/**
* Register a new function defined with annotations on a java class.
* @param func the function class
*/
@Override
public void registerFunction(Class func) throws ProcedureException {
for (var function : compiler.compileFunction(func, false)) {
registry.register(function);
}
}
/**
* Register a new aggregation function defined with annotations on a java class.
* @param func the function class
*/
@Override
public void registerAggregationFunction(Class func) throws ProcedureException {
for (var aggregation : compiler.compileAggregationFunction(func)) {
registry.register(aggregation);
}
}
/**
* Registers a type and its mapping to Neo4jTypes
*
* @param javaClass
* the class of the native type
* @param type
* the mapping to Neo4jTypes
*/
@Override
public void registerType(Class javaClass, Neo4jTypes.AnyType type) {
typeCheckers.registerType(javaClass, new TypeCheckers.DefaultValueConverter(type));
}
/**
* Registers a component, these become available in reflective procedures for injection.
* @param cls the type of component to be registered (this is what users 'ask' for in their field declaration)
* @param provider a function that supplies the component, given the context of a procedure invocation
* @param safe set to false if this component can bypass security, true if it respects security
*/
@Override
public void registerComponent(
Class cls, ThrowingFunction provider, boolean safe) {
if (safe) {
safeComponents.register(cls, provider);
}
allComponents.register(cls, provider);
}
@VisibleForTesting
@Override
public void unregister(QualifiedName name) {
registry.unregister(name);
}
@Override
public ProcedureView getCurrentView() {
return currentProcedureView.getAcquire();
}
@SuppressWarnings("RedundantThrows")
@Override
public LoadInformation reloadProceduresFromDisk(Transaction tx, Predicate namespaceFilter)
throws KernelException, IOException {
throw new UnsupportedOperationException("bulk registration does not support loading from disk");
}
@Override
public void close() {
onClose.close();
}
}
private static ProcedureView makeSnapshot(
ProcedureRegistry registry, ComponentRegistry safeComponents, ComponentRegistry allComponents) {
return ProcedureViewImpl.snapshot(
SIGNATURE_VERSION_GENERATOR.incrementAndGet(), registry, safeComponents, allComponents);
}
/**
* The RegistrationLatch is responsible for protecting concurrent mutation
* of the internals of the GlobalProceduresRegistry, as well as generating
* new snapshots upon finishing mutations.
*/
private class RegistrationUpdater {
private final ReentrantLock lock = new ReentrantLock();
Resource acquire() {
lock.lock();
return () -> {
try {
currentProcedureView.setRelease(makeSnapshot(registry, safeComponents, allComponents));
} finally {
lock.unlock();
}
};
}
Resource acquireFromTransaction(InternalTransaction tx) {
// When we reload procedures from disk, we want to verify that nothing has happened in-between
// the transaction started, and the lock was claimed. Furthermore, we should not wait for the lock,
// but rather fail with a transient error to avoid blocking a transaction.
if (!lock.tryLock()) {
throw new TransientTransactionFailureException(
Status.Procedure.ProcedureCallFailed,
"The procedure registry is busy. You may retry this operation.");
}
if (tx.kernelTransaction().procedures().signatureVersion()
!= getCurrentView().signatureVersion()) {
lock.unlock();
throw new TransientTransactionFailureException(
Status.Procedure.ProcedureCallFailed,
"The procedure registry was modified by another transaction. You may retry this operation.");
}
return () -> {
try {
currentProcedureView.setRelease(makeSnapshot(registry, safeComponents, allComponents));
} finally {
lock.unlock();
}
};
}
}
}