-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
Kernel.java
156 lines (140 loc) · 5.83 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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/*
* Copyright (c) 2002-2018 "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.internal.kernel.api.Modes;
import org.neo4j.internal.kernel.api.Session;
import org.neo4j.internal.kernel.api.Transaction;
import org.neo4j.internal.kernel.api.exceptions.ProcedureException;
import org.neo4j.internal.kernel.api.security.LoginContext;
import org.neo4j.kernel.api.InwardKernel;
import org.neo4j.kernel.api.KernelTransaction;
import org.neo4j.kernel.api.TransactionHook;
import org.neo4j.internal.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.configuration.Config;
import org.neo4j.kernel.impl.newapi.NewKernel;
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;
import org.neo4j.storageengine.api.StorageEngine;
import static org.neo4j.graphdb.factory.GraphDatabaseSettings.transaction_timeout;
/**
* 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).
*
* WARNING: This class is under transition.
*
* <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 InwardKernel
{
private final KernelTransactions transactions;
private final TransactionHooks hooks;
private final DatabaseHealth health;
private final TransactionMonitor transactionMonitor;
private final Procedures procedures;
private final Config config;
private final NewKernel newKernel;
public Kernel( KernelTransactions transactionFactory, TransactionHooks hooks, DatabaseHealth health,
TransactionMonitor transactionMonitor, Procedures procedures, Config config, StorageEngine engine )
{
this.transactions = transactionFactory;
this.hooks = hooks;
this.health = health;
this.transactionMonitor = transactionMonitor;
this.procedures = procedures;
this.config = config;
this.newKernel = new NewKernel( engine, this );
}
@Override
public KernelTransaction newTransaction( Transaction.Type type, LoginContext loginContext )
throws TransactionFailureException
{
return newTransaction( type, loginContext, config.get( transaction_timeout ).toMillis() );
}
@Override
public KernelTransaction newTransaction( Transaction.Type type, LoginContext loginContext, long timeout ) throws
TransactionFailureException
{
health.assertHealthy( TransactionFailureException.class );
KernelTransaction transaction = transactions.newInstance( type, loginContext, timeout );
transactionMonitor.transactionStarted();
return transaction;
}
@Override
public void registerTransactionHook( TransactionHook hook )
{
hooks.register( 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 start()
{
newKernel.start();
}
@Override
public void stop()
{
newKernel.stop();
}
@Override
public Session beginSession( LoginContext loginContext )
{
return newKernel.beginSession( loginContext );
}
@Override
public Modes modes()
{
return newKernel;
}
}