/*******************************************************************************
* Copyright (c) 2007 Cambridge Semantics Incorporated.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* File: $Source$
* Created by: Matthew Roy ( <a href="mailto:mroy@cambridgesemantics.com">mroy@cambridgesemantics.com </a>)
* Created on: Oct 29, 2007
* Revision: $Id$
*
* Contributors:
* Cambridge Semantics Incorporated - initial API and implementation
*******************************************************************************/
package org.openanzo.datasource.nodecentric.internal;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.Reader;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.Properties;
import java.util.StringTokenizer;
import org.apache.commons.collections15.MultiMap;
import org.openanzo.datasource.DatasourceDictionary;
import org.openanzo.datasource.IDatasource;
import org.openanzo.datasource.nodecentric.sql.Backup;
import org.openanzo.datasource.nodecentric.sql.InsertStatementsRdbWrapper;
import org.openanzo.datasource.nodecentric.sql.LastTransactionTime;
import org.openanzo.datasource.nodecentric.sql.ServerRdbWrapper;
import org.openanzo.datasource.services.BaseResetService;
import org.openanzo.exceptions.AnzoException;
import org.openanzo.exceptions.AnzoRuntimeException;
import org.openanzo.exceptions.ExceptionConstants;
import org.openanzo.exceptions.LogUtils;
import org.openanzo.jdbc.container.sql.BaseSQL;
import org.openanzo.jdbc.utils.RdbException;
import org.openanzo.ontologies.openanzo.AnzoServer;
import org.openanzo.ontologies.openanzo.NamedGraph;
import org.openanzo.rdf.Constants;
import org.openanzo.rdf.Dataset;
import org.openanzo.rdf.IDataset;
import org.openanzo.rdf.MemTypedLiteral;
import org.openanzo.rdf.RDFFormat;
import org.openanzo.rdf.SegmentedStatementCollector;
import org.openanzo.rdf.Statement;
import org.openanzo.rdf.URI;
import org.openanzo.rdf.Constants.GRAPHS;
import org.openanzo.rdf.Constants.OSGI;
import org.openanzo.rdf.utils.Pair;
import org.openanzo.rdf.utils.ReadWriteUtils;
import org.openanzo.rdf.utils.SmartEncodingInputStream;
import org.openanzo.rdf.utils.UriGenerator;
import org.openanzo.rdf.vocabulary.RDF;
import org.openanzo.services.AnzoPrincipal;
import org.openanzo.services.IOperationContext;
import org.openanzo.services.impl.BaseOperationContext;
import org.openanzo.services.serialization.BackupRevision;
import org.openanzo.services.serialization.IBackupHandler;
import org.openanzo.services.serialization.XMLBackupReader;
import org.osgi.service.event.Event;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* NodeCentric implementation of the IResetService
*
* @author Matthew Roy ( <a href="mailto:mroy@cambridgesemantics.com">mroy@cambridgesemantics.com </a>)
*
*/
class NodeCentricResetService extends BaseResetService {
private static final Logger log = LoggerFactory.getLogger(NodeCentricResetService.class);
private final NodeCentricDatasource datasource;
private static final String resourcePrefix = "resource:";
private static final String initServerStatement = "initServerTables";
private static final String initTablespace = "initTablespace";
private static final String initDBtables = "initDBtables";
private static final String initIndexes = "initIndexes";
private static final String initSequences = "initSequences";
private static final String dropSequence = "DROP SEQUENCE ";
private static final String dropView = "DROP VIEW ";
private static final String dropTable = "DROP TABLE ";
static final String[] liveTables = { "NAMEDGRAPHS", "NAMEDGRAPHS_NR", "STATEMENTS", "STATEMENTS_NR", "LASTTRANSACTIONTIME", "LOCKED_GRAPHS", "TRANSACTIONTIME", "QUERY_GRAPHS" };
private static final String[] tempTables = { "DEFAULTGRAPHS_TMP", "NAMEDGRAPHS_TMP", "TEMPGRAPHS", "TEMP_COLUMNS", "SUBJECT_IDS_TEMP", "PREDICATE_IDS_TEMP", "OBJECT_IDS_TEMP", "NAMEDGRAPH_IDS_TEMP", "ID_TMP", "RES_TMP", "LIT_TMP", "STMTS_TMP", "NGR_TMP", "STMTS_REP_TMP", "STMT_ID_TMP", "REMOVE_GRAPHS_TMP", "TEMP_CONSTRAINT0", "TEMP_CONSTRAINT1", "TEMP_CONSTRAINT2", "TEMP_CONSTRAINT3" };
private static final String[] staticTables = { "GLITTERUNIT" };
private static final String[][] sequences = { { "NODE_SEQ_0", "NODE_SEQ_1", "NODE_SEQ_2", "NODE_SEQ_3", "NODE_SEQ_4", "NODE_SEQ_5", "NODE_SEQ_6" }, {}, {}, {}, {}, {}, {}, {}, { "DATATYPE_SEQ", "LANG_SEQ" }, {}, {}, {}, {}, {}, {}, {}, {} };
private static final String[] views = { "ALL_STMTS_VIEW", "ALL_LITERALS_VIEW" };
private String[] nodeCentricTables = null;
private Collection<String> rdfInitFiles = null;
private boolean hardReset = false;
protected NodeCentricResetService(boolean resetEnabled, NodeCentricDatasource datasource) {
super(resetEnabled, datasource.getEventAdmin());
this.datasource = datasource;
}
public IDatasource getDatasource() {
return datasource;
}
@Override
public void start() throws AnzoException {
String[] postfixes = new String[] { "_B", "_L", "_LL", "_LU", "_U", "_USED_IDS", "_TL", "_LTL", "_DATATYPE", "_LANGUAGE" };
nodeCentricTables = new String[postfixes.length];
for (int i = 0; i < postfixes.length; i++) {
nodeCentricTables[i] = datasource.getConfiguration().getContainerName() + postfixes[i];
}
String intResources = DatasourceDictionary.getInitFiles(datasource.getConfigurationParameters());
if (intResources != null && intResources.length() > 0) {
rdfInitFiles = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(intResources, ",");
while (st.hasMoreTokens()) {
rdfInitFiles.add(st.nextToken());
}
}
//this.aclEventListeners = datasource.getAclEventListeners();
hardReset = datasource.getConfiguration().getUseHardReset();
}
/**
* Reset the database
*
* @param connectionContext
* NodeCentric specific context, which contains connection to run queries against
* @param hardReset
* if true, all tables are dropped and not just truncated
* @param statements
* statements to use to initialize database
* @return ValuePair containing servers new URI and ID
* @throws AnzoException
*/
protected URI resetDatabase(NodeCentricOperationContext connectionContext, boolean hardReset, MultiMap<URI, Statement> statements) throws AnzoException {
datasource.resetDatasource();
Pair<Long, URI> serverURI = null;
boolean[] result = lockDB(connectionContext);
if (result[1]) {
try {
serverURI = resetDatabaseTables(connectionContext, hardReset);
if (statements != null && statements.size() > 0) {
resetGraph(statements, connectionContext, serverURI.second);
} else {
if (rdfInitFiles != null && rdfInitFiles.size() > 0) {
initializeProvidedRoles(connectionContext, serverURI.second);
} else {
initializeDefaultRoles(connectionContext, serverURI.second);
}
}
unLockDB(connectionContext, true, serverURI.first);
return serverURI.second;
} catch (AnzoException ae) {
if (result[0]) {
BaseSQL.dropTable(connectionContext.getStatementProvider(), connectionContext.getConnection(), connectionContext.getConfiguration().getUsesUppercase() ? NodeCentricDatasource.serverUpper : NodeCentricDatasource.serverLower);
}
throw ae;
}
} else {
if (result[0]) {
BaseSQL.dropTable(connectionContext.getStatementProvider(), connectionContext.getConnection(), connectionContext.getConfiguration().getUsesUppercase() ? NodeCentricDatasource.serverUpper : NodeCentricDatasource.serverLower);
}
throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_DB);
}
}
@Override
protected URI resetInternal(IOperationContext context, MultiMap<URI, Statement> statements, java.util.Collection<org.openanzo.rdf.Statement> checks) throws AnzoException {
NodeCentricOperationContext connectionContext = null;
try {
connectionContext = datasource.getWriteContext(context);
return resetDatabase(connectionContext, getUseHardReset(), statements);
} finally {
if (connectionContext != null) {
datasource.returnWriteContext(connectionContext);
}
}
}
/*
* Reset the underlying JDBC database tables
*/
private Pair<Long, URI> resetDatabaseTables(NodeCentricOperationContext connectionContext, boolean hardReset) throws AnzoException {
try {
dropTables(connectionContext, hardReset);
datasource.begin(connectionContext.getConnection(), true, true);
Long ts = Long.valueOf(0);
LastTransactionTime.insertFirstTransactionTime(connectionContext.getStatementProvider(), connectionContext.getConnection(), ts);
URI serverUri = UriGenerator.generateServerIdURI();
Long serverId = connectionContext.getNodeLayout().store(serverUri, connectionContext.getConnection(), 1);
ServerRdbWrapper.setServerId(connectionContext.getStatementProvider(), connectionContext.getConnection(), serverId);
connectionContext.getNodeLayout().store(Constants.EVERYONE_ROLE, connectionContext.getConnection(), 1);
datasource.commit(connectionContext.getConnection(), true, true);
connectionContext.getNodeLayout().commitReferencedIds(connectionContext.getConnection(), 1);
return new Pair<Long, URI>(serverId, serverUri);
} catch (Exception e) {
log.error(LogUtils.RDB_MARKER, "SQL Error resetting database tables", e);
datasource.abort(connectionContext.getConnection(), true, true);
throw new AnzoException(ExceptionConstants.RDB.OPERATION_ERROR, e, e.getMessage());
}
}
/*
* Initialize default system information with data from RepositoryInitializationFile if no system graph information was
* provided
*/
private void initializeProvidedRoles(NodeCentricOperationContext context, URI serverURI) throws AnzoException {
SegmentedStatementCollector sc = new SegmentedStatementCollector();
try {
if (log.isWarnEnabled()) {
log.warn(LogUtils.RDB_MARKER, "Initializing database from files: {}", Arrays.toString(rdfInitFiles.toArray()));
}
for (String file : rdfInitFiles) {
ReadWriteUtils.parseStatements(SmartEncodingInputStream.createSmartReader(getLocationAsStream(file)), RDFFormat.forFileName(file), "", sc);
}
} catch (AnzoException mse) {
throw new AnzoRuntimeException(mse);
}
resetGraph(sc.getStatements(), context, serverURI);
}
private static final String ID_STRING = "{0}:{1}:{2}:{3}";
public void restoreData(String fileName) throws AnzoException {
final NodeCentricOperationContext connectionContext = datasource.getWriteContext(new BaseOperationContext("RESTORE", BaseOperationContext.generateOperationId(), new AnzoPrincipal("sysadmin", null, null, true, false)));
if (getLockProvider() != null) {
getLockProvider().writeLock().lock();
}
try {
datasource.resetStarting();
datasource.reset();
if (eventAdmin != null)
eventAdmin.sendEvent(new Event(OSGI.RESET_TOPIC, (Dictionary<Object, Object>) new Properties()));
Pair<Long, URI> serverURI = null;
datasource.resetDatasource();
boolean[] result = lockDB(connectionContext);
if (result[1]) {
try {
serverURI = resetDatabaseTables(connectionContext, hardReset);
try {
Reader fileReader = ReadWriteUtils.createSmartFileReader(fileName);
XMLBackupReader reader = new XMLBackupReader(fileReader);
try {
reader.read(new IBackupHandler() {
Long graphId;
Long metaId;
Long uuidId;
public void start() throws AnzoException {
datasource.begin(connectionContext.getConnection(), true, true);
}
public void handleStatement(boolean metadata, boolean revisioned, Statement statement, Long start, Long end) throws AnzoException {
Long s = connectionContext.getNodeLayout().store(statement.getSubject(), connectionContext.getConnection(), 1);
Long p = connectionContext.getNodeLayout().store(statement.getPredicate(), connectionContext.getConnection(), 1);
Long o = connectionContext.getNodeLayout().store(statement.getObject(), connectionContext.getConnection(), 1);
String stmtId = MessageFormat.format(ID_STRING, (metadata) ? metaId.toString() : graphId.toString(), s.toString(), p.toString(), o.toString());
if (revisioned) {
Backup.restoreStatement(connectionContext.getStatementProvider(), connectionContext.getConnection(), stmtId, metadata ? 1 : 0, uuidId, metadata ? metaId : graphId, s, p, o, start, end);
} else {
Backup.restoreStatementNR(connectionContext.getStatementProvider(), connectionContext.getConnection(), stmtId, metadata ? 1 : 0, metadata ? metaId : graphId, s, p, o);
}
}
public boolean handleNamedGraph(boolean revisioned, URI namedGraphUri, URI metadataURI, URI uuid, Collection<BackupRevision> revisions) throws AnzoException {
try {
connectionContext.getConnection().commit();
} catch (SQLException sqle) {
throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_COMMIT_RDB_TRANSACTION, sqle);
}
uuidId = connectionContext.getNodeLayout().store(uuid, connectionContext.getConnection(), 1);
graphId = connectionContext.getNodeLayout().store(namedGraphUri, connectionContext.getConnection(), 1);
metaId = connectionContext.getNodeLayout().store(metadataURI, connectionContext.getConnection(), 1);
for (BackupRevision backup : revisions) {
Long lastMod = connectionContext.getNodeLayout().store(backup.lastModifiedBy, connectionContext.getConnection(), 1);
if (revisioned) {
Backup.restoreNamedGraph(connectionContext.getStatementProvider(), connectionContext.getConnection(), backup.start, backup.end, graphId, metaId, uuidId, backup.revision, lastMod);
} else {
Backup.restoreNamedGraphNR(connectionContext.getStatementProvider(), connectionContext.getConnection(), backup.start, graphId, metaId, uuidId, backup.revision, lastMod);
}
}
return true;
}
public void end() throws AnzoException {
datasource.commit(connectionContext.getConnection(), true, true);
connectionContext.getNodeLayout().commitReferencedIds(connectionContext.getConnection(), 1);
}
});
} catch (AnzoException ae) {
datasource.abort(connectionContext.getConnection(), true, true);
} finally {
if (fileReader != null) {
fileReader.close();
}
}
} catch (Exception e) {
log.error(LogUtils.RDB_MARKER, "Error resetting datasource", e);
}
datasource.getIndexHandler().rebuildIndex(true);
} catch (AnzoException ae) {
if (result[0]) {
BaseSQL.dropTable(connectionContext.getStatementProvider(), connectionContext.getConnection(), connectionContext.getConfiguration().getUsesUppercase() ? NodeCentricDatasource.serverUpper : NodeCentricDatasource.serverLower);
}
throw ae;
}
unLockDB(connectionContext, true, serverURI.first);
datasource.postReset();
datasource.resetFinished();
} else {
if (result[0]) {
BaseSQL.dropTable(connectionContext.getStatementProvider(), connectionContext.getConnection(), connectionContext.getConfiguration().getUsesUppercase() ? NodeCentricDatasource.serverUpper : NodeCentricDatasource.serverLower);
}
throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_DB);
}
} finally {
if (getLockProvider() != null) {
getLockProvider().writeLock().unlock();
}
datasource.returnWriteContext(connectionContext);
}
}
private boolean[] lockDB(NodeCentricOperationContext connectionContext) {
boolean ownsIt = false;
try {
connectionContext.getStatementProvider().runSQLGroup(initServerStatement, datasource.getInitParams(), connectionContext.getConnection());
ownsIt = true;
} catch (SQLException sqle) {
if (log.isDebugEnabled()) {
log.debug(LogUtils.RDB_MARKER, "SQL Error initializing SERVER table", sqle);
}
} catch (RdbException sqle) {
if (log.isDebugEnabled()) {
log.debug(LogUtils.RDB_MARKER, "SQL Error initializing SERVER table", sqle);
}
}
try {
int counter = ServerRdbWrapper.setInitializing(connectionContext.getStatementProvider(), connectionContext.getConnection(), System.currentTimeMillis());
if (counter == 0) {
ServerRdbWrapper.setInitializingFailed(connectionContext.getStatementProvider(), connectionContext.getConnection());
return new boolean[] { ownsIt, false };
}
return new boolean[] { ownsIt, true };
} catch (AnzoException sqle) {
if (log.isErrorEnabled()) {
log.error(LogUtils.RDB_MARKER, "Error unlocking db", sqle);
}
return new boolean[] { ownsIt, false };
}
}
private void unLockDB(NodeCentricOperationContext connectionContext, boolean passed, long serverId) {
if (passed) {
try {
ServerRdbWrapper.setInitialized(connectionContext.getStatementProvider(), connectionContext.getConnection(), serverId);
} catch (AnzoException sqle) {
log.error(LogUtils.RDB_MARKER, "Error unlocking db", sqle);
}
} else {
try {
ServerRdbWrapper.setInitializingFailed(connectionContext.getStatementProvider(), connectionContext.getConnection());
} catch (AnzoException sqle) {
log.error(LogUtils.RDB_MARKER, "Error unlocking db", sqle);
}
}
}
private void dropTables(NodeCentricOperationContext connectionContext, boolean hardReset) throws AnzoException, SQLException {
long start = System.currentTimeMillis();
if (hardReset) {
String[][] tableSets = { liveTables, nodeCentricTables, staticTables };
datasource.begin(connectionContext.getConnection(), true, true);
java.sql.Statement stmt = connectionContext.getConnection().createStatement();
try {
for (String view : views) {
try {
stmt.executeUpdate(dropView + datasource.getConfiguration().getDropExtras() + " " + view);
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping view", sqle);
}
}
}
for (String[] sequenceVers : sequences) {
if (sequenceVers != null) {
for (String sequence : sequenceVers) {
try {
stmt.executeUpdate(dropSequence + datasource.getConfiguration().getDropExtras() + " " + sequence);
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping sequence", sqle);
}
}
}
}
}
if (!connectionContext.getConfiguration().getSupportsIdentity()) {
try {
stmt.executeUpdate(dropSequence + datasource.getConfiguration().getDropExtras() + " LANG_SEQ");
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping sequence", sqle);
}
}
try {
stmt.executeUpdate(dropSequence + datasource.getConfiguration().getDropExtras() + " DATATYPE_SEQ");
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping sequence", sqle);
}
}
}
for (String[] tables : tableSets) {
for (String table : tables) {
try {
stmt.executeUpdate(dropTable + datasource.getConfiguration().getDropExtras() + " " + table);
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping table", sqle);
}
}
}
}
for (String table : tempTables) {
try {
stmt.executeUpdate(dropTable + datasource.getConfiguration().getDropExtras() + " " + datasource.getConfiguration().getSessionPrefix() + table);
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error droping temptable", sqle);
}
}
}
} finally {
try {
stmt.close();
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error closing statement", sqle);
}
}
datasource.commit(connectionContext.getConnection(), true, true);
}
if (datasource.getConfiguration().getRequiresTempTablespace() && InsertStatementsRdbWrapper.getTempTablespaceDefined(connectionContext.getStatementProvider(), connectionContext.getConnection()) == 0) {
datasource.begin(connectionContext.getConnection(), true, true);
try {
connectionContext.getStatementProvider().runSQLGroup(initTablespace, new String[0], connectionContext.getConnection());
} catch (SQLException sqle) {
if (log.isErrorEnabled()) {
log.error(LogUtils.RDB_MARKER, "SQL Error initializing tablespace", sqle);
}
throw sqle;
} finally {
datasource.commit(connectionContext.getConnection(), true, true);
}
}
datasource.begin(connectionContext.getConnection(), true, true);
try {
connectionContext.getStatementProvider().runSQLGroup(initDBtables, datasource.getInitParams(), connectionContext.getConnection());
connectionContext.getStatementProvider().runSQLGroup(initIndexes, datasource.getInitParams(), connectionContext.getConnection());
connectionContext.getStatementProvider().runSQLGroup(initSequences, datasource.getInitParams(), connectionContext.getConnection());
datasource.commit(connectionContext.getConnection(), true, true);
} catch (SQLException sqle) {
log.error(LogUtils.RDB_MARKER, "Error initializing database tables", sqle);
datasource.abort(connectionContext.getConnection(), true, true);
throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_DB, sqle);
}
try {
datasource.begin(connectionContext.getConnection(), true, true);
connectionContext.getStatementProvider().runSQLGroup("createTemporaryTables", datasource.getInitParams(), connectionContext.getConnection());
datasource.commit(connectionContext.getConnection(), true, true);
} catch (SQLException sqle) {
log.error(LogUtils.RDB_MARKER, "Error initializing database temporary tables", sqle);
datasource.abort(connectionContext.getConnection(), true, true);
throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_TEMPTABLES, sqle);
}
} else {
String[][] tableSets = { liveTables, nodeCentricTables };
datasource.begin(connectionContext.getConnection(), true, true);
java.sql.Statement stmt = connectionContext.getConnection().createStatement();
try {
for (String[] tables : tableSets) {
for (String table : tables) {
try {
BaseSQL.truncateTableMayCommit(connectionContext.getStatementProvider(), connectionContext.getConnection(), table);
} catch (RdbException sqle) {
if (log.isErrorEnabled()) {
log.error(LogUtils.RDB_MARKER, "SQL Error truncating table", sqle);
}
}
}
}
} finally {
try {
stmt.close();
} catch (SQLException sqle) {
if (log.isTraceEnabled()) {
log.trace(LogUtils.RDB_MARKER, "SQL Error closing statement", sqle);
}
}
datasource.commit(connectionContext.getConnection(), true, true);
}
}
if (log.isDebugEnabled()) {
log.debug(LogUtils.RDB_MARKER, "[RESET DB] {}", (System.currentTimeMillis() - start));
}
}
/*
* Process the contents of the graph into the database
*/
private void resetGraph(MultiMap<URI, Statement> statements, NodeCentricOperationContext context, URI serverURI) throws AnzoException {
Collection<Statement> graphTemplates = new ArrayList<Statement>();
// If a graph doesn't have a corresponding metadata graph in the statements, then add a default metadata graph for it.
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, RDF.TYPE, NamedGraph.TYPE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, NamedGraph.revisionedProperty, MemTypedLiteral.create(true)));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, NamedGraph.persistedProperty, MemTypedLiteral.create(true)));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, NamedGraph.canBeReadByProperty, Constants.EVERYONE_ROLE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, NamedGraph.canBeAddedToByProperty, Constants.EVERYONE_ROLE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_GRAPH_TEMPLATE, NamedGraph.canBeRemovedFromByProperty, Constants.EVERYONE_ROLE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_METADATA_GRAPH_TEMPLATE, NamedGraph.canBeReadByProperty, Constants.EVERYONE_ROLE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_METADATA_GRAPH_TEMPLATE, NamedGraph.canBeAddedToByProperty, Constants.EVERYONE_ROLE));
graphTemplates.add(new Statement(GRAPHS.DEFAULT_METADATA_GRAPH_TEMPLATE, NamedGraph.canBeRemovedFromByProperty, Constants.EVERYONE_ROLE));
context.setAttribute("resetting", Boolean.valueOf(true));
statements.put(GRAPHS.DEFAULT_SYSTEMGRAPH, Constants.valueFactory.createStatement(GRAPHS.DEFAULT_SYSTEMGRAPH, AnzoServer.serverIdProperty, serverURI, GRAPHS.DEFAULT_SYSTEMGRAPH));
datasource.getUpdateService().importStatements(context, statements.values(), graphTemplates);
}
/*
* Process the contents of the graph into the database
*/
private void initializeDefaultRoles(NodeCentricOperationContext context, URI serverURI) throws AnzoException {
context.setAttribute("resetting", Boolean.valueOf(true));
IDataset dataset = new Dataset();
//System graph
dataset.addNamedGraph(GRAPHS.DEFAULT_SYSTEMGRAPH);
dataset.addNamedGraph(GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, AnzoServer.serverIdProperty, serverURI, GRAPHS.DEFAULT_SYSTEMGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, RDF.TYPE, org.openanzo.ontologies.openanzo.NamedGraph.TYPE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.persistedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.revisionedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.EVERYONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.NOONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEMGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.NOONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEM_METAGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.NOONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEM_METAGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.NOONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
dataset.add(GRAPHS.DEFAULT_SYSTEM_METAGRAPH, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.NOONE_ROLE, GRAPHS.DEFAULT_SYSTEM_METAGRAPH);
//Graph Dataset
dataset.addNamedGraph(GRAPHS.GRAPHS_DATASET);
dataset.addNamedGraph(GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, RDF.TYPE, org.openanzo.ontologies.openanzo.Dataset.TYPE, GRAPHS.GRAPHS_DATASET);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.Dataset.namedGraphProperty, GRAPHS.DEFAULT_SYSTEMGRAPH, GRAPHS.GRAPHS_DATASET);
dataset.add(GRAPHS.GRAPHS_DATASET, RDF.TYPE, org.openanzo.ontologies.openanzo.NamedGraph.TYPE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.persistedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.revisionedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.EVERYONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.EVERYONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.EVERYONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.NOONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.NOONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
dataset.add(GRAPHS.GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.NOONE_ROLE, GRAPHS.GRAPHS_DATASET_META);
//MetadataGraph Dataset
dataset.addNamedGraph(GRAPHS.METADATA_GRAPHS_DATASET);
dataset.addNamedGraph(GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, RDF.TYPE, org.openanzo.ontologies.openanzo.Dataset.TYPE, GRAPHS.METADATA_GRAPHS_DATASET);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.Dataset.namedGraphProperty, GRAPHS.DEFAULT_SYSTEM_METAGRAPH, GRAPHS.METADATA_GRAPHS_DATASET);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, RDF.TYPE, org.openanzo.ontologies.openanzo.NamedGraph.TYPE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.persistedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.revisionedProperty, Constants.valueFactory.createTypedLiteral(Boolean.TRUE), GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.EVERYONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.EVERYONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.NOONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeReadByProperty, Constants.NOONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeAddedToByProperty, Constants.NOONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
dataset.add(GRAPHS.METADATA_GRAPHS_DATASET_META, org.openanzo.ontologies.openanzo.NamedGraph.canBeRemovedFromByProperty, Constants.NOONE_ROLE, GRAPHS.METADATA_GRAPHS_DATASET_META);
datasource.getUpdateService().importStatements(context, dataset.getStatements(), Collections.<Statement> emptySet());
}
/**
* Convert a string to an InputStream
*
* @param location
* Location of data to convert to an InputStream
* @return the location converted to an InputStream
* @throws AnzoException
*/
private InputStream getLocationAsStream(String location) throws AnzoException {
InputStream initializationStream = null;
if (location.startsWith(resourcePrefix)) {
String resourceLocation = location.substring(resourcePrefix.length());
initializationStream = this.getClass().getResourceAsStream(resourceLocation);
if (initializationStream == null) {
throw new AnzoException(ExceptionConstants.SERVER.INIT_FILE, resourceLocation);
}
} else {
File initializationFile = new File(location);
try {
initializationStream = SmartEncodingInputStream.createSmartStream(new FileInputStream(initializationFile));
} catch (FileNotFoundException e2) {
throw new AnzoException(ExceptionConstants.SERVER.INIT_FILE, initializationFile.getAbsolutePath());
}
}
return initializationStream;
}
/**
* @return the nodeCentricTables
*/
public String[] getNodeCentricTables() {
return nodeCentricTables;
}
public String[] getRequiredTables() {
return liveTables;
}
public String[][] getRequiredSequences() {
return sequences;
}
public String[] getRequiredViews() {
return views;
}
/**
* Get if the server uses hard resets to clear database tables
*
* @return true if the server uses hard resets to clear database tables
*/
public boolean getUseHardReset() {
return hardReset;
}
/**
* Set whether or not the server uses hard resets to clear database tables
*
* @param hardReset
* whether or not the server uses hard resets to clear database tables
*/
public void setUseHardReset(boolean hardReset) {
this.hardReset = hardReset;
}
@Override
protected void resetChecks(IOperationContext context, Collection<Statement> checks) throws AnzoException {
}
}