-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
Kernel.java
124 lines (114 loc) · 5.08 KB
/
Kernel.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
* Copyright (c) 2002-2016 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.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 <http://www.gnu.org/licenses/>.
*/
package org.neo4j.kernel.impl.api;
import org.neo4j.graphdb.factory.GraphDatabaseSettings;
import org.neo4j.kernel.api.KernelAPI;
import org.neo4j.kernel.api.KernelTransaction;
import org.neo4j.kernel.api.TransactionHook;
import org.neo4j.kernel.api.exceptions.ProcedureException;
import org.neo4j.kernel.api.exceptions.TransactionFailureException;
import org.neo4j.kernel.api.proc.CallableProcedure;
import org.neo4j.kernel.api.proc.CallableUserFunction;
import org.neo4j.kernel.api.security.SecurityContext;
import org.neo4j.kernel.configuration.Config;
import org.neo4j.kernel.impl.proc.Procedures;
import org.neo4j.kernel.impl.transaction.TransactionMonitor;
import org.neo4j.kernel.internal.DatabaseHealth;
import org.neo4j.kernel.lifecycle.LifecycleAdapter;
/**
* This is the Neo4j Kernel, an implementation of the Kernel API which is an internal component used by Cypher and the
* Core API (the API under org.neo4j.graphdb).
*
* <h1>Structure</h1>
*
* The Kernel lets you start transactions. The transactions allow you to create "statements", which, in turn, operate
* against the database. Statements and transactions are separate concepts due to isolation requirements. A single
* cypher query will normally use one statement, and there can be multiple statements executed in one transaction.
*
* Please refer to the {@link KernelTransaction} javadoc for details.
*
* The architecture of the kernel is based around a layered design, where one layer performs some task, and potentially
* delegates down to a lower layer. For instance, writing to the database will pass through
* {@link LockingStatementOperations}, which will grab locks and delegate to {@link StateHandlingStatementOperations}
* which will store the change in the transaction state, to be applied later if the transaction is committed.
*
* A read will, similarly, pass through {@link LockingStatementOperations}. It then reaches
* {@link StateHandlingStatementOperations}, which includes any changes that exist in the current transaction, and then
* finally {@link org.neo4j.storageengine.api.StoreReadLayer} will read the current committed state from
* the stores or caches.
*/
public class Kernel extends LifecycleAdapter implements KernelAPI
{
private final KernelTransactions transactions;
private final TransactionHooks hooks;
private final DatabaseHealth health;
private final TransactionMonitor transactionMonitor;
private final Procedures procedures;
private final long defaultTransactionTimeout;
public Kernel( KernelTransactions transactionFactory, TransactionHooks hooks, DatabaseHealth health,
TransactionMonitor transactionMonitor, Procedures procedures, Config config )
{
this.transactions = transactionFactory;
this.hooks = hooks;
this.health = health;
this.transactionMonitor = transactionMonitor;
this.procedures = procedures;
this.defaultTransactionTimeout = config.get( GraphDatabaseSettings.transaction_timeout );
}
@Override
public KernelTransaction newTransaction( KernelTransaction.Type type, SecurityContext securityContext ) throws TransactionFailureException
{
return newTransaction( type, securityContext, defaultTransactionTimeout );
}
@Override
public KernelTransaction newTransaction( KernelTransaction.Type type, SecurityContext securityContext, long timeout ) throws
TransactionFailureException
{
health.assertHealthy( TransactionFailureException.class );
KernelTransaction transaction = transactions.newInstance( type, securityContext, timeout );
transactionMonitor.transactionStarted();
return transaction;
}
@Override
public void registerTransactionHook( TransactionHook hook )
{
hooks.register( hook );
}
@Override
public void unregisterTransactionHook( TransactionHook hook )
{
hooks.unregister( hook );
}
@Override
public void registerProcedure( CallableProcedure procedure ) throws ProcedureException
{
procedures.register( procedure );
}
@Override
public void registerUserFunction( CallableUserFunction function ) throws ProcedureException
{
procedures.register( function );
}
@Override
public void stop() throws Throwable
{
transactions.disposeAll();
}
}