-
Notifications
You must be signed in to change notification settings - Fork 4
/
Rdf4jDeployModule.java
216 lines (186 loc) · 8.57 KB
/
Rdf4jDeployModule.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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
package cz.cvut.spipes.modules;
import cz.cvut.spipes.constants.KBSS_MODULE;
import cz.cvut.spipes.engine.ExecutionContext;
import cz.cvut.spipes.engine.ExecutionContextFactory;
import cz.cvut.spipes.exception.ModuleConfigurationInconsistentException;
import cz.cvut.spipes.util.CoreConfigProperies;
import org.apache.jena.rdf.model.Property;
import org.apache.jena.rdf.model.ResourceFactory;
import org.apache.jena.riot.RDFLanguages;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.repository.Repository;
import org.eclipse.rdf4j.repository.RepositoryConnection;
import org.eclipse.rdf4j.repository.RepositoryException;
import org.eclipse.rdf4j.repository.config.RepositoryConfig;
import org.eclipse.rdf4j.repository.config.RepositoryConfigException;
import org.eclipse.rdf4j.repository.manager.RemoteRepositoryManager;
import org.eclipse.rdf4j.repository.manager.RepositoryManager;
import org.eclipse.rdf4j.repository.manager.RepositoryProvider;
import org.eclipse.rdf4j.repository.sail.config.SailRepositoryConfig;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.RDFParseException;
import org.eclipse.rdf4j.sail.nativerdf.config.NativeStoreConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Optional;
/**
* Module deploys content of input execution context
* into default context of repository (if p-rdf4j-context-iri is not specified)
* or concrete context (if p-rdf4j-context-iri is specified).
*/
public class Rdf4jDeployModule extends AbstractModule {
private static final Logger LOG = LoggerFactory.getLogger(Rdf4jDeployModule.class);
private static String TYPE_URI = KBSS_MODULE.getURI()+"deploy";
private static String PROPERTY_PREFIX_URI = KBSS_MODULE.getURI()+"rdf4j";
private static Property getParameter(final String name) {
return ResourceFactory.createProperty(PROPERTY_PREFIX_URI + "/" + name);
}
/**
* URL of the Rdf4j server
*/
static final Property P_RDF4J_SERVER_URL = getParameter("p-rdf4j-server-url");
private String rdf4jServerURL;
/**
* Rdf4j repository ID
*/
static final Property P_RDF4J_REPOSITORY_NAME = getParameter("p-rdf4j-repository-name");
private String rdf4jRepositoryName;
/**
* IRI of the context that should be used for deployment
*/
static final Property P_RDF4J_CONTEXT_IRI = getParameter("p-rdf4j-context-iri");
private String rdf4jContextIRI;
static final Property P_RDF4J_REPOSITORY_USERNAME = getParameter("p-rdf4j-secured-username-variable");
private String rdf4jSecuredUsernameVariable;
private RepositoryManager repositoryManager;
private Repository repository;
public void setRepositoryManager(RepositoryManager repositoryManager) {
this.repositoryManager = repositoryManager;
}
static final Property P_RDF4J_REPOSITORY_PASSWORD = getParameter("p-rdf4j-secured-password-variable");
private String rdf4jSecuredPasswordVariable;
/**
* Whether data should be replaced (true) / appended (false) into the specified context or repository.
* Default is false.
*/
static final Property P_IS_REPLACE_CONTEXT_IRI = getParameter("p-is-replace");
private boolean isReplaceContext;
public String getRdf4jServerURL() {
return rdf4jServerURL;
}
public void setRdf4jServerURL(String rdf4jServerURL) {
this.rdf4jServerURL = rdf4jServerURL;
}
public String getRdf4jRepositoryName() {
return rdf4jRepositoryName;
}
public void setRdf4jRepositoryName(String rdf4jRepositoryName) {
this.rdf4jRepositoryName = rdf4jRepositoryName;
}
public String getRdf4jContextIRI() {
return rdf4jContextIRI;
}
public void setRdf4jContextIRI(String rdf4jContextIRI) {
this.rdf4jContextIRI = rdf4jContextIRI;
}
public boolean isReplaceContext() {
return isReplaceContext;
}
public void setReplaceContext(boolean replaceContext) {
isReplaceContext = replaceContext;
}
@Override
ExecutionContext executeSelf() {
LOG.debug("Deploying data into {} of rdf4j server repository {}/{}.",
isRdf4jContextIRIDefined() ? "context " + rdf4jContextIRI : "default context",
rdf4jServerURL,
rdf4jRepositoryName);
RepositoryConnection connection = null;
try {
if (repository == null) {
LOG.info("Creating new repository {} within rdf4j server {} ...",
rdf4jServerURL, rdf4jRepositoryName);
RepositoryConfig repConfig = new RepositoryConfig(rdf4jRepositoryName);
SailRepositoryConfig config = new SailRepositoryConfig(new NativeStoreConfig());
repConfig.setRepositoryImplConfig(config);
repositoryManager.addRepositoryConfig(repConfig);
repository = repositoryManager.getRepository(rdf4jRepositoryName);
}
repository.initialize();
connection = repository.getConnection();
final Resource rdf4jContextIRIResource =
isRdf4jContextIRIDefined() ? connection.getValueFactory().createIRI(rdf4jContextIRI) : null;
connection.begin();
if (isReplaceContext) {
connection.clear( rdf4jContextIRIResource );
}
StringWriter w = new StringWriter();
executionContext.getDefaultModel().write(w, RDFLanguages.NTRIPLES.getName());
connection.add(new StringReader(w.getBuffer().toString()), "", RDFFormat.N3, rdf4jContextIRIResource);
connection.commit();
} catch (final RepositoryException | RDFParseException | RepositoryConfigException | IOException e) {
LOG.error(e.getMessage(),e);
} finally {
try {
if (connection != null && connection.isOpen()) {
connection.close();
}
} catch (RepositoryException e) {
LOG.error(e.getMessage(), e);
} finally {
if ((repository != null) && (repository.isInitialized())) {
try {
repository.shutDown();
} catch (RepositoryException e) {
LOG.error("During finally: ", e);
}
}
}
}
return ExecutionContextFactory.createContext(executionContext.getDefaultModel());
}
@Override
public String getTypeURI() {
return TYPE_URI;
}
@Override
public void loadConfiguration() {
rdf4jServerURL = getEffectiveValue(P_RDF4J_SERVER_URL).asLiteral().getString();
rdf4jRepositoryName = getEffectiveValue(P_RDF4J_REPOSITORY_NAME).asLiteral().getString();
if (this.getPropertyValue(P_RDF4J_CONTEXT_IRI) != null) {
rdf4jContextIRI = getEffectiveValue(P_RDF4J_CONTEXT_IRI).asLiteral().getString();
}
isReplaceContext = this.getPropertyValue(P_IS_REPLACE_CONTEXT_IRI, false);
rdf4jSecuredUsernameVariable = Optional.ofNullable(
getEffectiveValue(P_RDF4J_REPOSITORY_USERNAME)).map(n -> n.asLiteral().getString()
).orElse(null);
rdf4jSecuredPasswordVariable = Optional.ofNullable(
getEffectiveValue(P_RDF4J_REPOSITORY_PASSWORD)).map(n -> n.asLiteral().getString()
).orElse(null);
if (repositoryManager != null && rdf4jServerURL != null) {
throw new ModuleConfigurationInconsistentException(
"Repository manager is already initialized. Trying to override its configuration from RDF.");
}
repositoryManager = RepositoryProvider.getRepositoryManager(rdf4jServerURL);
String username = getConfigurationVariable(rdf4jSecuredUsernameVariable);
String password = getConfigurationVariable(rdf4jSecuredPasswordVariable);
if (username != null && password != null) {
RemoteRepositoryManager remoteRepositoryManager = (RemoteRepositoryManager) repositoryManager;
remoteRepositoryManager.setUsernameAndPassword(username, password);
}
repository = repositoryManager.getRepository(rdf4jRepositoryName);
}
private static @Nullable String getConfigurationVariable(String variableName) {
if (variableName == null) {
return null;
}
return CoreConfigProperies.getConfigurationVariable(variableName);
}
private boolean isRdf4jContextIRIDefined() {
return (rdf4jContextIRI != null) && (!rdf4jContextIRI.isEmpty());
}
}