/// <summary>
/// Lists the Graphs in the Store
/// </summary>
/// <returns></returns>
public virtual IEnumerable <Uri> ListGraphs()
{
try
{
//Technically the ?s ?p ?o is unecessary here but we may not get the right results if we don't include this because some stores
//won't interpret GRAPH ?g { } correctly
Object results = this.Query("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }");
if (results is SparqlResultSet)
{
List <Uri> graphs = new List <Uri>();
foreach (SparqlResult r in ((SparqlResultSet)results))
{
if (r.HasValue("g"))
{
INode temp = r["g"];
if (temp.NodeType == NodeType.Uri)
{
graphs.Add(((IUriNode)temp).Uri);
}
}
}
return(graphs);
}
else
{
return(Enumerable.Empty <Uri>());
}
}
catch (Exception ex)
{
throw StorageHelper.HandleError(ex, "listing Graphs from");
}
}
/// <summary>
/// Gets the List of Graphs from the store
/// </summary>
/// <returns></returns>
public override IEnumerable <Uri> ListGraphs()
{
try
{
SparqlResultSet results = this.Query("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }") as SparqlResultSet;
if (results != null)
{
List <Uri> uris = new List <Uri>();
foreach (SparqlResult r in results)
{
if (r.HasValue("g"))
{
INode n = r["g"];
if (n != null && n.NodeType == NodeType.Uri)
{
uris.Add(((IUriNode)n).Uri);
}
}
}
return(uris);
}
else
{
throw new RdfStorageException("Tried to list graphs from Fuseki but failed to get a SPARQL Result Set as expected");
}
}
catch (RdfStorageException)
{
throw;
}
catch (Exception ex)
{
throw StorageHelper.HandleError(ex, "listing Graphs from");
}
}
/// <summary>
/// Lists the Graphs in the Store
/// </summary>
/// <returns></returns>
public IEnumerable <Uri> ListGraphs()
{
try
{
Object results = Query("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }");
if (results is SparqlResultSet)
{
List <Uri> graphs = new List <Uri>();
foreach (SparqlResult r in ((SparqlResultSet)results))
{
if (r.HasValue("g"))
{
INode temp = r["g"];
if (temp.NodeType == NodeType.Uri)
{
graphs.Add(((IUriNode)temp).Uri);
}
}
}
return(graphs);
}
else
{
return(Enumerable.Empty <Uri>());
}
}
catch (Exception ex)
{
throw StorageHelper.HandleError(ex, "listing Graphs from");
}
}
/// <summary>
/// Lists the Graphs from the Repository
/// </summary>
/// <returns></returns>
public IEnumerable <Uri> ListGraphs()
{
try
{
//Use the /contexts method to get the Graph URIs
//HACK: Have to use SPARQL JSON as currently Dydra's SPARQL XML Results are malformed
HttpWebRequest request = this.CreateRequest("/contexts", MimeTypesHelper.CustomHttpAcceptHeader(MimeTypesHelper.SparqlResultsJson), "GET", new Dictionary <string, string>());
SparqlResultSet results = new SparqlResultSet();
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
parser.Load(results, new StreamReader(response.GetResponseStream()));
response.Close();
}
List <Uri> graphUris = new List <Uri>();
foreach (SparqlResult r in results)
{
if (r.HasValue("contextID"))
{
INode value = r["contextID"];
if (value.NodeType == NodeType.Uri)
{
graphUris.Add(((IUriNode)value).Uri);
}
else if (value.NodeType == NodeType.Blank)
{
//Dydra allows BNode Graph URIs
graphUris.Add(UriFactory.Create("dydra:bnode:" + ((IBlankNode)value).InternalID));
}
}
}
return(graphUris);
}
catch (Exception ex)
{
throw StorageHelper.HandleError(ex, "list Graphs from");
}
}
/// <summary>
/// Helper method for doing async delete operations, callers just need to provide an appropriately prepared HTTP request
/// </summary>
/// <param name="request">HTTP request</param>
/// <param name="allow404">Whether a 404 response counts as success</param>
/// <param name="graphUri">URI of the Graph to delete</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
protected internal void DeleteGraphAsync(HttpWebRequest request, bool allow404, String graphUri, AsyncStorageCallback callback, Object state)
{
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r);
//Assume if returns to here we deleted the Graph OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.DeleteGraph, graphUri.ToSafeUri()), state);
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
//Don't throw the error if we get a 404 - this means we couldn't do a delete as the graph didn't exist to start with
if (webEx.Response == null || (webEx.Response != null && (!allow404 || ((HttpWebResponse)webEx.Response).StatusCode != HttpStatusCode.NotFound)))
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.DeleteGraph, graphUri.ToSafeUri(), new RdfStorageException("A HTTP Error occurred while trying to delete a Graph from the Store asynchronously", webEx)), state);
}
else
{
//Consider a 404 as a success in some cases
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.DeleteGraph, graphUri.ToSafeUri()), state);
}
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.DeleteGraph, graphUri.ToSafeUri(), StorageHelper.HandleError(ex, "deleting a Graph asynchronously from")), state);
}
}, state);
}
/// <summary>
/// Helper method for doing async update operations, callers just need to provide an appropriately prepared HTTP request and a RDF writer which will be used to write the data to the request body
/// </summary>
/// <param name="request">HTTP Request</param>
/// <param name="writer">RDF writer</param>
/// <param name="graphUri">URI of the Graph to update</param>
/// <param name="ts">Triples</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
protected internal void UpdateGraphAsync(HttpWebRequest request, IRdfWriter writer, Uri graphUri, IEnumerable <Triple> ts, AsyncStorageCallback callback, Object state)
{
Graph g = new Graph();
g.Assert(ts);
request.BeginGetRequestStream(r =>
{
try
{
Stream reqStream = request.EndGetRequestStream(r);
writer.Save(g, new StreamWriter(reqStream));
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
//If we get here then it was OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.UpdateGraph, graphUri), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.UpdateGraph, graphUri, StorageHelper.HandleHttpError(webEx, "updating a Graph asynchronously in")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.UpdateGraph, graphUri, StorageHelper.HandleError(ex, "updating a Graph asynchronously in")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.UpdateGraph, graphUri, StorageHelper.HandleHttpError(webEx, "updating a Graph asynchronously in")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.UpdateGraph, graphUri, StorageHelper.HandleError(ex, "updating a Graph asynchronously in")), state);
}
}, state);
}
/// <summary>
/// Helper method for doing async save operations, callers just need to provide an appropriately perpared HTTP requests and a RDF writer which will be used to write the data to the request body
/// </summary>
/// <param name="request">HTTP request</param>
/// <param name="writer">RDF Writer</param>
/// <param name="g">Graph to save</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
protected internal void SaveGraphAsync(HttpWebRequest request, IRdfWriter writer, IGraph g, AsyncStorageCallback callback, Object state)
{
request.BeginGetRequestStream(r =>
{
try
{
Stream reqStream = request.EndGetRequestStream(r);
writer.Save(g, new StreamWriter(reqStream));
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
//If we get here then it was OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SaveGraph, g), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SaveGraph, g, StorageHelper.HandleHttpError(webEx, "saving a Graph asynchronously to")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SaveGraph, g, StorageHelper.HandleError(ex, "saving a Graph asynchronously to")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SaveGraph, g, StorageHelper.HandleHttpError(webEx, "saving a Graph asynchronously to")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SaveGraph, g, StorageHelper.HandleError(ex, "saving a Graph asynchronously to")), state);
}
}, state);
}
/// <summary>
/// Helper method for doing async load operations, callers just need to provide an appropriately prepared HTTP request
/// </summary>
/// <param name="request">HTTP Request</param>
/// <param name="handler">Handler to load with</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
protected internal void LoadGraphAsync(HttpWebRequest request, IRdfHandler handler, AsyncStorageCallback callback, Object state)
{
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r);
Tools.HttpDebugResponse(response);
//Parse the retrieved RDF
IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType);
parser.Load(handler, new StreamReader(response.GetResponseStream()));
//If we get here then it was OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, handler), state);
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
if (((HttpWebResponse)webEx.Response).StatusCode == HttpStatusCode.NotFound)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, handler), state);
return;
}
}
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, handler, new RdfStorageException("A HTTP Error occurred while trying to load a Graph from the Store", webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, handler, StorageHelper.HandleError(ex, "loading a Graph asynchronously from")), state);
}
}, state);
}
/// <summary>
/// Makes a SPARQL Update request to the Allegro Graph server
/// </summary>
/// <param name="sparqlUpdate">SPARQL Update</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public virtual void Update(string sparqlUpdate, AsyncStorageCallback callback, Object state)
{
try
{
HttpWebRequest request;
//Create the Request
request = this.CreateRequest(this._repositoriesPrefix + this._store + this._updatePath, MimeTypesHelper.Any, "POST", new Dictionary <String, String>());
//Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(HttpUtility.UrlEncode(EscapeQuery(sparqlUpdate)));
request.BeginGetRequestStream(r =>
{
try
{
Stream stream = request.EndGetRequestStream(r);
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(postData);
writer.Close();
}
Tools.HttpDebugRequest(request);
//Get the Response and process based on the Content Type
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
//If we get here it completed OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}
/// <summary>
/// Executes SPARQL Updates against the Fuseki store
/// </summary>
/// <param name="sparqlUpdate">SPARQL Update</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public void Update(String sparqlUpdate, AsyncStorageCallback callback, Object state)
{
try
{
// Make the SPARQL Update Request
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this._updateUri);
request.Method = "POST";
request.ContentType = "application/sparql-update";
request = base.ApplyRequestOptions(request);
request.BeginGetRequestStream(r =>
{
try
{
Stream stream = request.EndGetRequestStream(r);
StreamWriter writer = new StreamWriter(stream);
writer.Write(sparqlUpdate);
writer.Close();
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
// If we get here without erroring then the request was OK
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, sparqlUpdate, StorageHelper.HandleError(ex, "updating")), state);
}
}
/// <summary>
/// Updates the store asynchronously
/// </summary>
/// <param name="sparqlUpdates">SPARQL Update</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public void Update(string sparqlUpdates, AsyncStorageCallback callback, object state)
{
try
{
HttpWebRequest request = this.CreateRequest("/sparql", MimeTypesHelper.HttpSparqlAcceptHeader, "POST", null);
request.BeginGetRequestStream(r =>
{
try
{
Stream stream = request.EndGetRequestStream(r);
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write("query=");
writer.Write(HttpUtility.UrlEncode(sparqlUpdates));
writer.Close();
}
Tools.HttpDebugRequest(request);
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
//If we get here then it completed OK
response.Close();
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleError(ex, "updating")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpError(webEx, "updating")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleError(ex, "updating")), state);
}
}
/// <summary>
/// Lists the Graphs from the Repository
/// </summary>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
/// <returns></returns>
public override void ListGraphs(AsyncStorageCallback callback, Object state)
{
try
{
//Use the /contexts method to get the Graph URIs
//HACK: Have to use SPARQL JSON as currently Dydra's SPARQL XML Results are malformed
HttpWebRequest request = this.CreateRequest("/contexts", MimeTypesHelper.CustomHttpAcceptHeader(MimeTypesHelper.SparqlResultsJson), "GET", new Dictionary <string, string>());
request.BeginGetResponse(r =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r);
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
ListUrisHandler handler = new ListUrisHandler("contextID");
parser.Load(handler, new StreamReader(response.GetResponseStream()));
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, handler.Uris), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleHttpError(webEx, "list Graphs asynchronously from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleError(ex, "list Graphs asynchronously from")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleHttpError(webEx, "list Graphs asynchronously from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleError(ex, "list Graphs asynchronously from")), state);
}
}
