/// <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); } }