Github user spmallette commented on a diff in the pull request:
https://github.com/apache/tinkerpop/pull/569#discussion_r106412544
--- Diff:
gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/DefaultGraphManager.java
---
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.server.util;
+
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
+import org.apache.tinkerpop.gremlin.server.GraphManager;
+import org.apache.tinkerpop.gremlin.server.GremlinServer;
+import org.apache.tinkerpop.gremlin.server.Settings;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Transaction;
+import org.apache.tinkerpop.gremlin.structure.util.GraphFactory;
+import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.script.Bindings;
+import javax.script.SimpleBindings;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * Holder for {@link Graph} and {@link TraversalSource} instances
configured for the server to be passed to script
+ * engine bindings. The {@link Graph} instances are read from the {@link
Settings} for Gremlin Server as defined in
+ * the configuration file. The {@link TraversalSource} instances are
rebound to the {@code GraphManager} once
+ * initialization scripts construct them.
+ */
+public final class DefaultGraphManager implements GraphManager {
+ private static final Logger logger =
LoggerFactory.getLogger(GremlinServer.class);
+
+ private final Map<String, Graph> graphs = new ConcurrentHashMap<>();
+ private final Map<String, TraversalSource> traversalSources = new
ConcurrentHashMap<>();
+
+ /**
+ * Create a new instance using the {@link Settings} from Gremlin
Server.
+ */
+ public DefaultGraphManager(final Settings settings) {
+ settings.graphs.entrySet().forEach(e -> {
+ try {
+ final Graph newGraph = GraphFactory.open(e.getValue());
+ graphs.put(e.getKey(), newGraph);
+ logger.info("Graph [{}] was successfully configured via
[{}].", e.getKey(), e.getValue());
+ } catch (RuntimeException re) {
+ logger.warn(String.format("Graph [%s] configured at [%s]
could not be instantiated and will not be available in Gremlin Server.
GraphFactory message: %s",
+ e.getKey(), e.getValue(), re.getMessage()), re);
+ if (re.getCause() != null) logger.debug("GraphFactory
exception", re.getCause());
+ }
+ });
+ }
+
+ /**
+ * Get a list of the {@link Graph} instances and their binding names
as defined in the Gremlin Server
+ * configuration file.
+ *
+ * @return a {@link Map} where the key is the name of the {@link
Graph} and the value is the {@link Graph} itself
+ */
+ public Map<String, Graph> getGraphs() {
+ return graphs;
+ }
+
+ public Graph getGraph(String gName) {
+ return graphs.get(gName);
+ }
+
+ public void addGraph(String gName, Graph g) {
+ graphs.put(gName, g);
+ }
+
+ /**
+ * Get a list of the {@link TraversalSource} instances and their
binding names as defined by Gremlin Server
+ * initialization scripts.
+ *
+ * @return a {@link Map} where the key is the name of the {@link
TraversalSource} and the value is the
+ * {@link TraversalSource} itself
+ */
+ public Map<String, TraversalSource> getTraversalSources() {
+ return traversalSources;
+ }
+
+ public TraversalSource getTraversalSource(String tsName) {
+ return traversalSources.get(tsName);
+ }
+
+ public void addTraversalSource(String tsName, TraversalSource ts) {
+ traversalSources.put(tsName, ts);
+ }
+
+ /**
+ * Get the {@link Graph} and {@link TraversalSource} list as a set of
bindings.
+ */
+ public Bindings getAsBindings() {
+ final Bindings bindings = new SimpleBindings();
+ graphs.forEach(bindings::put);
+ traversalSources.forEach(bindings::put);
+ return bindings;
+ }
+
+ /**
+ * Rollback transactions across all {@link Graph} objects.
+ */
+ public void rollbackAll() {
+ graphs.entrySet().forEach(e -> {
+ final Graph graph = e.getValue();
+ if (graph.features().graph().supportsTransactions() &&
graph.tx().isOpen())
+ graph.tx().rollback();
+ });
+ }
+
+ /**
+ * Selectively rollback transactions on the specified graphs or the
graphs of traversal sources.
+ */
+ public void rollback(final Set<String> graphSourceNamesToCloseTxOn) {
+ closeTx(graphSourceNamesToCloseTxOn, Transaction.Status.ROLLBACK);
+ }
+
+ /**
+ * Commit transactions across all {@link Graph} objects.
+ */
+ public void commitAll() {
+ graphs.entrySet().forEach(e -> {
+ final Graph graph = e.getValue();
+ if (graph.features().graph().supportsTransactions() &&
graph.tx().isOpen())
+ graph.tx().commit();
+ });
+ }
+
+ /**
+ * Selectively commit transactions on the specified graphs or the
graphs of traversal sources.
+ */
+ public void commit(final Set<String> graphSourceNamesToCloseTxOn) {
+ closeTx(graphSourceNamesToCloseTxOn, Transaction.Status.COMMIT);
+ }
+
+ /**
+ * Basic graphManager has basic openGraph function.
+ */
+ public Graph openGraph(String graphName, Supplier<Graph> supplier) {
+ final Graph graph = graphs.get(graphName);
+ if (null != graph) {
+ return graph;
+ }
+ return supplier.get();
+ }
+
+ /**
+ * Close graph
+ */
+ public void closeGraph(Graph graph) {
+ try {
+ graph.close();
--- End diff --
What does it mean to actually call `closeGraph()`? If "closed" does that
mean it should still be in the available set of graphs? If so it would still be
accessible to requests but it would be in a closed state. Different graphs will
have different semantics with respect to what `close()` will do. Anyway, just
posing the issue for thought at this point....not sure i have a strong opinion
yet on what the behavior should be.
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at [email protected] or file a JIRA ticket
with INFRA.
---
