public void StorageSparqlUniformHttpProtocolAddTriples()
{
try
{
SetUriLoaderCaching(false);
StorageSparqlUniformHttpProtocolSaveGraph();
Graph g = new Graph();
g.Retract(g.Triples.Where(t => !t.IsGroundTriple));
FileLoader.Load(g, "resources\\InferenceTest.ttl");
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
sparql.UpdateGraph("http://example.org/sparqlTest", g.Triples, null);
Graph h = new Graph();
sparql.LoadGraph(h, "http://example.org/sparqlTest");
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Assert.IsTrue(g.IsSubGraphOf(h), "Retrieved Graph should have the added Triples as a Sub Graph");
}
finally
{
SetUriLoaderCaching(true);
}
}
public void StorageSparqlUniformHttpProtocolRemoveTriples()
{
try
{
SetUriLoaderCaching(false);
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
try
{
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
sparql.UpdateGraph("http://example.org/sparqlTest", null, g.Triples);
Assert.Fail("SPARQL Uniform HTTP Protocol does not support removing Triples");
}
catch (RdfStorageException storeEx)
{
Console.WriteLine("Got an error as expected");
TestTools.ReportError("Storage Error", storeEx);
}
catch (NotSupportedException ex)
{
Console.WriteLine("Got a Not Supported error as expected");
TestTools.ReportError("Not Supported", ex);
}
}
finally
{
SetUriLoaderCaching(true);
}
}
public void StorageSparqlUniformHttpProtocolDeleteGraph()
{
try
{
SetUriLoaderCaching(false);
StorageSparqlUniformHttpProtocolSaveGraph();
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
sparql.DeleteGraph("http://example.org/sparqlTest");
//Give SPARQL Uniform Protocol time to delete stuff
Thread.Sleep(1000);
try
{
Graph g = new Graph();
sparql.LoadGraph(g, "http://example.org/sparqlTest");
//If we do get here without erroring then the Graph should be empty
Assert.IsTrue(g.IsEmpty, "If the Graph loaded without error then it should have been empty as we deleted it from the store");
}
catch (Exception ex)
{
Console.WriteLine("Errored as expected since the Graph was deleted");
TestTools.ReportError("Error", ex);
}
}
finally
{
SetUriLoaderCaching(true);
}
}
public void StorageSparqlUniformHttpProtocolPostCreateMultiple()
{
SparqlHttpProtocolConnector connector = SparqlGraphStoreProtocolTest.GetConnection();
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
List <Uri> uris = new List <Uri>();
for (int i = 0; i < 10; i++)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri));
request.Method = "POST";
request.ContentType = "application/rdf+xml";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, writer);
writer.Close();
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
//Should get a 201 Created response
if (response.StatusCode == HttpStatusCode.Created)
{
if (response.Headers["Location"] == null)
{
Assert.Fail("A Location: Header containing the URI of the newly created Graph should have been returned");
}
Uri graphUri = new Uri(response.Headers["Location"]);
uris.Add(graphUri);
Console.WriteLine("New Graph URI is " + graphUri.ToString());
Console.WriteLine("Now attempting to retrieve this Graph from the Store");
Graph h = new Graph();
connector.LoadGraph(h, graphUri);
Assert.AreEqual(g, h, "Graphs should have been equal");
Console.WriteLine("Graphs were equal as expected");
}
else
{
Assert.Fail("A 201 Created response should have been received but got a " + (int)response.StatusCode + " response");
}
response.Close();
}
Console.WriteLine();
}
Assert.IsTrue(uris.Distinct().Count() == 10, "Should have generated 10 distinct URIs");
}
public void StorageSparqlUniformHttpProtocolSaveGraph()
{
try
{
SetUriLoaderCaching(false);
Graph g = new Graph();
FileLoader.Load(g, "resources\\Turtle.ttl");
g.BaseUri = new Uri("http://example.org/sparqlTest");
//Save Graph to SPARQL Uniform Protocol
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
sparql.SaveGraph(g);
Console.WriteLine("Graph saved to SPARQL Uniform Protocol OK");
//Now retrieve Graph from SPARQL Uniform Protocol
Graph h = new Graph();
sparql.LoadGraph(h, "http://example.org/sparqlTest");
Console.WriteLine();
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
GraphDiffReport diff = g.Difference(h);
if (!diff.AreEqual)
{
Console.WriteLine();
Console.WriteLine("Graphs are different - should be 1 difference due to New Line Normalization");
Console.WriteLine("Added Triples");
foreach (Triple t in diff.AddedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Console.WriteLine("Removed Triples");
foreach (Triple t in diff.RemovedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Assert.IsTrue(diff.AddedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization");
Assert.IsTrue(diff.RemovedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization");
Assert.IsFalse(diff.AddedMSGs.Any(), "Should not be any MSG differences");
Assert.IsFalse(diff.RemovedMSGs.Any(), "Should not be any MSG differences");
}
}
finally
{
SetUriLoaderCaching(true);
}
}
public void StorageSparqlUniformHttpProtocolSaveGraph()
{
try
{
Options.UriLoaderCaching = false;
Graph g = new Graph();
FileLoader.Load(g, "Turtle.ttl");
g.BaseUri = new Uri("http://example.org/sparqlTest");
//Save Graph to SPARQL Uniform Protocol
SparqlHttpProtocolConnector sparql = new SparqlHttpProtocolConnector(new Uri(ProtocolTestUri));
sparql.SaveGraph(g);
Console.WriteLine("Graph saved to SPARQL Uniform Protocol OK");
//Now retrieve Graph from SPARQL Uniform Protocol
Graph h = new Graph();
sparql.LoadGraph(h, "http://example.org/sparqlTest");
Console.WriteLine();
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
GraphDiffReport diff = g.Difference(h);
if (!diff.AreEqual)
{
Console.WriteLine();
Console.WriteLine("Graphs are different - should be 1 difference due to New Line Normalization");
Console.WriteLine("Added Triples");
foreach (Triple t in diff.AddedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Console.WriteLine("Removed Triples");
foreach (Triple t in diff.RemovedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Assert.IsTrue(diff.AddedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization");
Assert.IsTrue(diff.RemovedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization");
Assert.IsFalse(diff.AddedMSGs.Any(), "Should not be any MSG differences");
Assert.IsFalse(diff.RemovedMSGs.Any(), "Should not be any MSG differences");
}
}
finally
{
Options.UriLoaderCaching = true;
}
}
public void StorageSparqlUniformHttpProtocolLoadGraph()
{
try
{
SetUriLoaderCaching(false);
//Ensure that the Graph will be there using the SaveGraph() test
StorageSparqlUniformHttpProtocolSaveGraph();
Graph g = new Graph();
FileLoader.Load(g, "resources\\Turtle.ttl");
g.BaseUri = new Uri("http://example.org/sparqlTest");
//Try to load the relevant Graph back from the Store
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
Graph h = new Graph();
sparql.LoadGraph(h, "http://example.org/sparqlTest");
Console.WriteLine();
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
GraphDiffReport diff = g.Difference(h);
if (!diff.AreEqual)
{
Console.WriteLine();
Console.WriteLine("Graphs are different - should be 1 difference due to New Line Normalization");
Console.WriteLine("Added Triples");
foreach (Triple t in diff.AddedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Console.WriteLine("Removed Triples");
foreach (Triple t in diff.RemovedTriples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Assert.True(diff.AddedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization (added)");
Assert.True(diff.RemovedTriples.Count() == 1, "Should only be 1 Triple difference due to New Line normalization (removed)");
Assert.False(diff.AddedMSGs.Any(), "Should not be any MSG differences");
Assert.False(diff.RemovedMSGs.Any(), "Should not be any MSG differences");
}
}
finally
{
SetUriLoaderCaching(true);
}
}
public void StorageSparqlUniformHttpProtocolPostCreate()
{
SparqlHttpProtocolConnector connector = SparqlGraphStoreProtocolTest.GetConnection();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri));
request.Method = "POST";
request.ContentType = "application/rdf+xml";
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, writer);
writer.Close();
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
//Should get a 201 Created response
if (response.StatusCode == HttpStatusCode.Created)
{
if (response.Headers["Location"] == null)
{
Assert.True(false, "A Location: Header containing the URI of the newly created Graph should have been returned");
}
Uri graphUri = new Uri(response.Headers["Location"]);
Console.WriteLine("New Graph URI is " + graphUri.ToString());
Console.WriteLine("Now attempting to retrieve this Graph from the Store");
Graph h = new Graph();
connector.LoadGraph(h, graphUri);
TestTools.ShowGraph(h);
Assert.Equal(g, h);
}
else
{
Assert.True(false, "A 201 Created response should have been received but got a " + (int)response.StatusCode + " response");
}
response.Close();
}
}
public void StorageSparqlUniformHttpProtocolGraphExists()
{
try
{
SetUriLoaderCaching(false);
//Ensure that the Graph will be there using the SaveGraph() test
StorageSparqlUniformHttpProtocolSaveGraph();
//Check the Graph exists in the Store
SparqlHttpProtocolConnector sparql = SparqlGraphStoreProtocolTest.GetConnection();
Assert.IsTrue(sparql.HasGraph("http://example.org/sparqlTest"));
}
finally
{
SetUriLoaderCaching(true);
}
}
/// <summary>
/// Tries to load a Generic IO Manager based on information from the Configuration Graph
/// </summary>
/// <param name="g">Configuration Graph</param>
/// <param name="objNode">Object Node</param>
/// <param name="targetType">Target Type</param>
/// <param name="obj">Output Object</param>
/// <returns></returns>
public bool TryLoadObject(IGraph g, INode objNode, Type targetType, out object obj)
{
IGenericIOManager manager = null;
obj = null;
String server, user, pwd, store;
bool isAsync;
Object temp;
INode storeObj;
//Create the URI Nodes we're going to use to search for things
INode propServer = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyServer),
propDb = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyDatabase),
propStore = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyStore),
propAsync = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyAsync);
switch (targetType.FullName)
{
case AllegroGraph:
//Get the Server, Catalog and Store
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
String catalog = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyCatalog));
store = ConfigurationLoader.GetConfigurationString(g, objNode, propStore);
if (store == null) return false;
//Get User Credentials
ConfigurationLoader.GetUsernameAndPassword(g, objNode, true, out user, out pwd);
if (user != null && pwd != null)
{
manager = new AllegroGraphConnector(server, catalog, store, user, pwd);
}
else
{
manager = new AllegroGraphConnector(server, catalog, store);
}
break;
case DatasetFile:
//Get the Filename and whether the loading should be done asynchronously
String file = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyFromFile));
if (file == null) return false;
file = ConfigurationLoader.ResolvePath(file);
isAsync = ConfigurationLoader.GetConfigurationBoolean(g, objNode, propAsync, false);
manager = new DatasetFileManager(file, isAsync);
break;
case Dydra:
//Get the Account Name and Store
String account = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyCatalog));
if (account == null) return false;
store = ConfigurationLoader.GetConfigurationString(g, objNode, propStore);
if (store == null) return false;
//Get User Credentials
ConfigurationLoader.GetUsernameAndPassword(g, objNode, true, out user, out pwd);
if (user != null)
{
manager = new DydraConnector(account, store, user);
}
else
{
manager = new DydraConnector(account, store);
}
break;
case FourStore:
//Get the Server and whether Updates are enabled
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
bool enableUpdates = ConfigurationLoader.GetConfigurationBoolean(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyEnableUpdates), true);
manager = new FourStoreConnector(server, enableUpdates);
break;
case Fuseki:
//Get the Server URI
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
manager = new FusekiConnector(server);
break;
case InMemory:
//Get the Dataset/Store
INode datasetObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUsingDataset));
if (datasetObj != null)
{
temp = ConfigurationLoader.LoadObject(g, datasetObj);
if (temp is ISparqlDataset)
{
manager = new InMemoryManager((ISparqlDataset)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the In-Memory Manager identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:usingDataset property points to an Object that cannot be loaded as an object which implements the ISparqlDataset interface");
}
}
else
{
//If no dnr:usingDataset try dnr:usingStore instead
storeObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUsingStore));
if (storeObj != null)
{
temp = ConfigurationLoader.LoadObject(g, storeObj);
if (temp is IInMemoryQueryableStore)
{
manager = new InMemoryManager((IInMemoryQueryableStore)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the In-Memory Manager identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:usingStore property points to an Object that cannot be loaded as an object which implements the IInMemoryQueryableStore interface");
}
}
else
{
//If no dnr:usingStore either then create a new empty store
manager = new InMemoryManager();
}
}
break;
case Joseki:
//Get the Query and Update URIs
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
String queryService = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyQueryPath));
if (queryService == null) return false;
String updateService = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUpdatePath));
if (updateService == null)
{
manager = new JosekiConnector(server, queryService);
}
else
{
manager = new JosekiConnector(server, queryService, updateService);
}
break;
case ReadOnly:
//Get the actual Manager we are wrapping
storeObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyGenericManager));
temp = ConfigurationLoader.LoadObject(g, storeObj);
if (temp is IGenericIOManager)
{
manager = new ReadOnlyConnector((IGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Read-Only Connector identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:genericManager property points to an Object which cannot be loaded as an object which implements the required IGenericIOManager interface");
}
break;
case ReadOnlyQueryable:
//Get the actual Manager we are wrapping
storeObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyGenericManager));
temp = ConfigurationLoader.LoadObject(g, storeObj);
if (temp is IQueryableGenericIOManager)
{
manager = new QueryableReadOnlyConnector((IQueryableGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Queryable Read-Only Connector identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:genericManager property points to an Object which cannot be loaded as an object which implements the required IQueryableGenericIOManager interface");
}
break;
case Sesame:
case SesameV5:
case SesameV6:
//Get the Server and Store ID
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
store = ConfigurationLoader.GetConfigurationString(g, objNode, propStore);
if (store == null) return false;
ConfigurationLoader.GetUsernameAndPassword(g, objNode, true, out user, out pwd);
if (user != null && pwd != null)
{
manager = (IGenericIOManager)Activator.CreateInstance(targetType, new Object[] { server, store, user, pwd });
}
else
{
manager = (IGenericIOManager)Activator.CreateInstance(targetType, new Object[] { server, store });
}
break;
case Sparql:
//Get the Endpoint URI or the Endpoint
server = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyEndpointUri));
//What's the load mode?
String loadModeRaw = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyLoadMode));
SparqlConnectorLoadMethod loadMode = SparqlConnectorLoadMethod.Construct;
if (loadModeRaw != null)
{
try
{
#if SILVERLIGHT
loadMode = (SparqlConnectorLoadMethod)Enum.Parse(typeof(SparqlConnectorLoadMethod), loadModeRaw, false);
#else
loadMode = (SparqlConnectorLoadMethod)Enum.Parse(typeof(SparqlConnectorLoadMethod), loadModeRaw);
#endif
}
catch
{
throw new DotNetRdfConfigurationException("Unable to load the SparqlConnector identified by the Node '" + objNode.ToString() + "' as the value given for the property dnr:loadMode is not valid");
}
}
if (server == null)
{
INode endpointObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyEndpoint));
if (endpointObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, endpointObj);
if (temp is SparqlRemoteEndpoint)
{
manager = new SparqlConnector((SparqlRemoteEndpoint)temp, loadMode);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the SparqlConnector identified by the Node '" + objNode.ToString() + "' as the value given for the property dnr:endpoint points to an Object which cannot be loaded as an object which is of the type SparqlRemoteEndpoint");
}
}
else
{
//Are there any Named/Default Graph URIs
IEnumerable<Uri> defGraphs = from def in ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyDefaultGraphUri))
where def.NodeType == NodeType.Uri
select ((IUriNode)def).Uri;
IEnumerable<Uri> namedGraphs = from named in ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyNamedGraphUri))
where named.NodeType == NodeType.Uri
select ((IUriNode)named).Uri;
if (defGraphs.Any() || namedGraphs.Any())
{
manager = new SparqlConnector(new SparqlRemoteEndpoint(new Uri(server), defGraphs, namedGraphs), loadMode);
}
else
{
manager = new SparqlConnector(new Uri(server), loadMode);
}
}
break;
case SparqlHttpProtocol:
//Get the Service URI
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
manager = new SparqlHttpProtocolConnector(new Uri(server));
break;
case Stardog:
//Get the Server and Store
server = ConfigurationLoader.GetConfigurationString(g, objNode, propServer);
if (server == null) return false;
store = ConfigurationLoader.GetConfigurationString(g, objNode, propStore);
if (store == null) return false;
//Get User Credentials
ConfigurationLoader.GetUsernameAndPassword(g, objNode, true, out user, out pwd);
//Get Reasoning Mode
StardogReasoningMode reasoning = StardogReasoningMode.None;
String mode = ConfigurationLoader.GetConfigurationString(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyLoadMode));
if (mode != null)
{
try
{
reasoning = (StardogReasoningMode)Enum.Parse(typeof(StardogReasoningMode), mode);
}
catch
{
reasoning = StardogReasoningMode.None;
}
}
if (user != null && pwd != null)
{
manager = new StardogConnector(server, store, reasoning, user, pwd);
}
else
{
manager = new StardogConnector(server, store, reasoning);
}
break;
case Talis:
//Get the Store Name and User credentials
store = ConfigurationLoader.GetConfigurationString(g, objNode, propStore);
if (store == null) return false;
ConfigurationLoader.GetUsernameAndPassword(g, objNode, true, out user, out pwd);
if (user != null && pwd != null)
{
manager = new TalisPlatformConnector(store, user, pwd);
}
else
{
manager = new TalisPlatformConnector(store);
}
break;
}
obj = manager;
return (manager != null);
}
public void StorageSparqlUniformHttpProtocolPostCreateMultiple()
{
SparqlHttpProtocolConnector connector = new SparqlHttpProtocolConnector("http://localhost/demos/server/");
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
List<Uri> uris = new List<Uri>();
for (int i = 0; i < 10; i++)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://localhost/demos/server/");
request.Method = "POST";
request.ContentType = "application/rdf+xml";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, writer);
writer.Close();
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
//Should get a 201 Created response
if (response.StatusCode == HttpStatusCode.Created)
{
if (response.Headers["Location"] == null) Assert.Fail("A Location: Header containing the URI of the newly created Graph should have been returned");
Uri graphUri = new Uri(response.Headers["Location"]);
uris.Add(graphUri);
Console.WriteLine("New Graph URI is " + graphUri.ToString());
Console.WriteLine("Now attempting to retrieve this Graph from the Store");
Graph h = new Graph();
connector.LoadGraph(h, graphUri);
Assert.AreEqual(g, h, "Graphs should have been equal");
Console.WriteLine("Graphs were equal as expected");
}
else
{
Assert.Fail("A 201 Created response should have been received but got a " + (int)response.StatusCode + " response");
}
response.Close();
}
Console.WriteLine();
}
Assert.IsTrue(uris.Distinct().Count() == 10, "Should have generated 10 distinct URIs");
}
public void StorageSparqlUniformHttpProtocolRemoveTriples()
{
try
{
Options.UriLoaderCaching = false;
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
try
{
SparqlHttpProtocolConnector sparql = new SparqlHttpProtocolConnector(new Uri(ProtocolTestUri));
sparql.UpdateGraph("http://example.org/sparqlTest", null, g.Triples);
Assert.Fail("SPARQL Uniform HTTP Protocol does not support removing Triples");
}
catch (RdfStorageException storeEx)
{
Console.WriteLine("Got an error as expected");
TestTools.ReportError("Storage Error", storeEx, false);
}
catch (NotSupportedException ex)
{
Console.WriteLine("Got a Not Supported error as expected");
TestTools.ReportError("Not Supported", ex, false);
}
}
finally
{
Options.UriLoaderCaching = true;
}
}
public void StorageSparqlUniformHttpProtocolAddTriples()
{
try
{
Options.UriLoaderCaching = false;
StorageSparqlUniformHttpProtocolSaveGraph();
Graph g = new Graph();
g.Retract(g.Triples.Where(t => !t.IsGroundTriple));
FileLoader.Load(g, "InferenceTest.ttl");
SparqlHttpProtocolConnector sparql = new SparqlHttpProtocolConnector(new Uri(ProtocolTestUri));
sparql.UpdateGraph("http://example.org/sparqlTest", g.Triples, null);
Graph h = new Graph();
sparql.LoadGraph(h, "http://example.org/sparqlTest");
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Assert.IsTrue(g.IsSubGraphOf(h), "Retrieved Graph should have the added Triples as a Sub Graph");
}
finally
{
Options.UriLoaderCaching = true;
}
}
public void StorageSparqlUniformHttpProtocolDeleteGraph()
{
try
{
Options.UriLoaderCaching = false;
StorageSparqlUniformHttpProtocolSaveGraph();
SparqlHttpProtocolConnector sparql = new SparqlHttpProtocolConnector(new Uri(ProtocolTestUri));
sparql.DeleteGraph("http://example.org/sparqlTest");
//Give SPARQL Uniform Protocol time to delete stuff
Thread.Sleep(1000);
try
{
Graph g = new Graph();
sparql.LoadGraph(g, "http://example.org/sparqlTest");
//If we do get here without erroring then the Graph should be empty
Assert.IsTrue(g.IsEmpty, "If the Graph loaded without error then it should have been empty as we deleted it from the store");
}
catch (Exception ex)
{
Console.WriteLine("Errored as expected since the Graph was deleted");
TestTools.ReportError("Error", ex, false);
}
}
finally
{
Options.UriLoaderCaching = true;
}
}
public void StorageSparqlUniformHttpProtocolGraphExists()
{
try
{
Options.UriLoaderCaching = false;
//Ensure that the Graph will be there using the SaveGraph() test
StorageSparqlUniformHttpProtocolSaveGraph();
//Check the Graph exists in the Store
SparqlHttpProtocolConnector sparql = new SparqlHttpProtocolConnector(new Uri(ProtocolTestUri));
Assert.IsTrue(sparql.GraphExists("http://example.org/sparqlTest"));
}
finally
{
Options.UriLoaderCaching = true;
}
}
static void DoProtocol(Dictionary<String, String> arguments)
{
String method;
SparqlHttpProtocolConnector endpoint;
bool verbose = arguments.ContainsKey("verbose") || arguments.ContainsKey("v");
if (verbose) Options.HttpDebugging = true;
Options.UriLoaderCaching = !arguments.ContainsKey("nocache");
String dataFile;
//First Argument must be HTTP Method
if (arguments.ContainsKey("$1") && !arguments["$1"].Equals(String.Empty))
{
method = arguments["$1"].ToUpper();
}
else
{
Console.Error.WriteLine("soh: Error: First argument must be one of head, get, put or post - type soh --help for details");
Environment.Exit(-1);
return;
}
try
{
if (arguments.ContainsKey("$2") && !arguments["$2"].Equals(String.Empty))
{
endpoint = new SparqlHttpProtocolConnector(new Uri(arguments["$2"]));
}
else
{
Console.Error.WriteLine("soh: Error: Second argument is required and must be the Dataset URI");
Environment.Exit(-1);
return;
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("soh: Error: Malformed SPARQL Endpoint URI");
Console.Error.WriteLine(uriEx.Message);
Environment.Exit(-1);
return;
}
if (verbose) Console.Error.WriteLine("soh: Connection to SPARQL Uniform HTTP Protocol endpoint created OK");
Uri graphUri;
try
{
if (arguments.ContainsKey("$3") && !arguments["$3"].Equals(String.Empty))
{
if (arguments["$3"].Equals("default"))
{
graphUri = null;
if (verbose) Console.Error.WriteLine("soh: Graph URI for Protocol request is 'default' (indicates the default unnamed graph)");
}
else
{
graphUri = new Uri(arguments["$3"]);
if (verbose) Console.Error.WriteLine("soh: Graph URI for Protocol request is '" + graphUri.ToString() + "'");
}
}
else
{
Console.Error.WriteLine("soh: Error: Third argument is required and must be the Graph URI or default to indicate the default unnamed Graph");
Environment.Exit(-1);
return;
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("soh: Error: Malformed Graph URI");
Console.Error.WriteLine(uriEx.Message);
Environment.Exit(-1);
return;
}
try
{
switch (method)
{
case "GET":
if (arguments.ContainsKey("$4"))
{
Console.Error.WriteLine("soh: Error: Optional file argument for protocol mode is not permitted with the get method");
Environment.Exit(-1);
return;
}
if (verbose) Console.Error.WriteLine("soh: Making a GET request to the Protocol endpoint");
Graph g = new Graph();
endpoint.LoadGraph(g, graphUri);
if (verbose) Console.Error.WriteLine("soh: Received a Graph with " + g.Triples.Count + " Triples");
//Use users choice of output format otherwise RDF/XML
MimeTypeDefinition definition = null;
if (arguments.ContainsKey("accept"))
{
definition = MimeTypesHelper.GetDefinitions(arguments["accept"]).FirstOrDefault(d => d.CanWriteRdf);
}
if (definition != null)
{
Console.OutputEncoding = definition.Encoding;
IRdfWriter writer = definition.GetRdfWriter();
writer.Save(g, new StreamWriter(Console.OpenStandardOutput(), definition.Encoding));
}
else
{
if (arguments.ContainsKey("accept") && verbose) Console.Error.WriteLine("soh: Warning: You wanted output in format '" + arguments["accept"] + "' but dotNetRDF does not support this format so RDF/XML will be returned instead");
RdfXmlWriter rdfXmlWriter = new RdfXmlWriter();
rdfXmlWriter.Save(g, new StreamWriter(Console.OpenStandardOutput(), Encoding.UTF8));
}
break;
case "HEAD":
if (arguments.ContainsKey("$4"))
{
Console.Error.WriteLine("soh: Error: Optional file argument for protocol mode is not permitted with the head method");
Environment.Exit(-1);
return;
}
if (verbose) Console.Error.WriteLine("soh: Making a HEAD request to the Protocol endpoint");
bool exists = endpoint.GraphExists(graphUri);
Console.WriteLine(exists.ToString().ToLower());
break;
case "PUT":
//Parse in the Graph to be PUT first
if (arguments.ContainsKey("$4") && !arguments["$4"].Equals(String.Empty))
{
dataFile = arguments["$4"];
}
else
{
Console.Error.WriteLine("soh: Error: The file argument for protocol mode is required when using the put method");
Environment.Exit(-1);
return;
}
Graph toPut = new Graph();
FileLoader.Load(toPut, dataFile);
toPut.BaseUri = graphUri;
if (verbose)
{
Console.Error.WriteLine("soh: Graph to be uploaded has " + toPut.Triples.Count + " Triples");
Console.Error.WriteLine("soh: Making a PUT request to the Protocol endpoint");
}
endpoint.SaveGraph(toPut);
Console.WriteLine("soh: Graph saved to Protocol endpoint OK");
break;
case "POST":
//Parse in the Graph to be PUT first
if (arguments.ContainsKey("$4") && !arguments["$4"].Equals(String.Empty))
{
dataFile = arguments["$4"];
}
else
{
Console.Error.WriteLine("soh: Error: The file argument for protocol mode is required when using the post method");
Environment.Exit(-1);
return;
}
Graph toPost = new Graph();
FileLoader.Load(toPost, dataFile);
if (verbose)
{
Console.Error.WriteLine("soh: Graph to be uploaded has " + toPost.Triples.Count + " Triples");
Console.Error.WriteLine("soh: Making a POST request to the Protocol endpoint");
}
endpoint.UpdateGraph(graphUri, toPost.Triples, null);
Console.WriteLine("soh: Graph updated to Protocol endpoint OK");
break;
case "DELETE":
if (arguments.ContainsKey("$4"))
{
Console.Error.WriteLine("soh: Error: Optional file argument for protocol mode is not permitted with the head method");
Environment.Exit(-1);
return;
}
endpoint.DeleteGraph(graphUri);
Console.WriteLine("soh: Graph deleted from Protocol endpoint OK");
break;
default:
Console.Error.WriteLine("soh: Error: " + method + " is not a HTTP Method supported by this tool");
Environment.Exit(-1);
return;
}
}
catch (Exception ex)
{
Console.Error.WriteLine("soh: Error: Error processing HTTP Protocol request");
Console.Error.WriteLine(ex.Message);
while (ex.InnerException != null)
{
Console.Error.WriteLine();
Console.Error.WriteLine(ex.InnerException.Message);
Console.Error.WriteLine(ex.InnerException.StackTrace);
ex = ex.InnerException;
}
Environment.Exit(-1);
return;
}
}
