-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
Kernel.java
131 lines (120 loc) · 5.33 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
125
126
127
128
129
130
131
/*
* Copyright (c) 2002-2017 "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.CallableUserAggregationFunction;
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 ).toMillis();
}
@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 registerUserAggregationFunction( CallableUserAggregationFunction function ) throws ProcedureException
{
procedures.register( function );
}
@Override
public void stop() throws Throwable
{
transactions.disposeAll();
}
}