/// <summary> /// Makes a SPARQL Query against the Knowledge Base /// </summary> /// <param name="sparqlQuery">SPARQL Query</param> /// <returns></returns> public Object Query(String sparqlQuery) { SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(UriFactory.Create(this._sparqlUri)); using (HttpWebResponse response = endpoint.QueryRaw(sparqlQuery)) { try { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } catch (RdfParserSelectionException) { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); SparqlResultSet results = new SparqlResultSet(); sparqlParser.Load(results, new StreamReader(response.GetResponseStream())); response.Close(); return(results); } } }
/// <summary> /// Gets the Raw Predictions Graph from the Knowledge Base /// </summary> /// <param name="individual">QName of an Individual</param> /// <param name="property">QName of a Property</param> /// <param name="callback">Callback to invoke when the operation completes</param> /// <param name="state">State to pass to the callback</param> public void PredictRaw(String individual, String property, GraphCallback callback, Object state) { String requestUri = this._predictUri + individual + "/" + property; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = this.Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(this.MimeTypes.Where(t => !t.Equals("text/json")), MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); request.BeginGetResponse(result => { using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result)) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); callback(g, state); } }, null); }
public void ServiceDescriptionOptionsRequestOnSparqlServer4() { EnsureIIS(); String server = TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUpdateUri); Console.WriteLine("Making an OPTIONS request to the web demos SPARQL Server Update Endpoint at " + server); Console.WriteLine(); NTriplesFormatter formatter = new NTriplesFormatter(); HttpWebRequest request = (HttpWebRequest)System.Net.WebRequest.Create(server); request.Method = "OPTIONS"; request.Accept = MimeTypesHelper.HttpAcceptHeader; using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); TestTools.ShowGraph(g); Assert.False(g.IsEmpty, "A non-empty Service Description Graph should have been returned"); response.Close(); } }
public void ServiceDescriptionOptionsRequestOnSparqlServer2() { EnsureIIS(); String path = TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri) + "some/long/path/elsewhere"; Console.WriteLine("Making an OPTIONS request to the web demos SPARQL Server at " + path); Console.WriteLine("This Test tries to ensure that the URI resolution works correctly"); Console.WriteLine(); NTriplesFormatter formatter = new NTriplesFormatter(); HttpWebRequest request = (HttpWebRequest)System.Net.WebRequest.Create(path); request.Method = "OPTIONS"; request.Accept = MimeTypesHelper.HttpAcceptHeader; using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); TestTools.ShowGraph(g); Assert.False(g.IsEmpty, "A non-empty Service Description Graph should have been returned"); response.Close(); } }
/// <summary> /// Makes a SPARQL Query against the underlying 4store Instance processing the results with the appropriate handler from those provided /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="sparqlQuery">SPARQL Query</param> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { try { //Ensure Proxy Settings have been taken from the class this._endpoint.Proxy = this.Proxy; this._endpoint.UseCredentialsForProxy = false; HttpWebResponse response = this._endpoint.QueryRaw(sparqlQuery); StreamReader data = new StreamReader(response.GetResponseStream()); try { //Is the Content Type referring to a Sparql Result Set format? ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(response.ContentType); resreader.Load(resultsHandler, data); response.Close(); } catch (RdfParserSelectionException) { //If we get a Parser Selection exception then the Content Type isn't valid for a Sparql Result Set //Is the Content Type referring to a RDF format? IRdfReader rdfreader = MimeTypesHelper.GetParser(response.ContentType); rdfreader.Load(rdfHandler, data); response.Close(); } } catch (WebException webEx) { throw StorageHelper.HandleHttpQueryError(webEx); } }
/// <summary> /// Gets the raw Similarity Graph for the Knowledge Base. /// </summary> /// <param name="number">Number of Similar Individuals.</param> /// <param name="individual">QName of a Individual to find Similar Individuals to.</param> /// <returns></returns> public IGraph SimilarityRaw(int number, String individual) { if (number < 1) { throw new RdfReasoningException("Pellet Server requires the number of Similar Individuals to be at least 1"); } String requestUri = _similarityUri + number + "/" + individual; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(MimeTypes.Where(t => !t.Equals("text/json")), MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } }
/// <summary> /// Gets a Graph explaining the result of the SPARQL Query. /// </summary> /// <param name="sparqlQuery">SPARQL Query.</param> /// <returns></returns> public IGraph Explain(String sparqlQuery) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_explainUri + "?query=" + HttpUtility.UrlEncode(sparqlQuery)); request.Method = Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(MimeTypes, MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } throw new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server", webEx); } }
/// <summary> /// Makes a Query against the SPARQL Endpoint processing the results with an appropriate handler from those provided /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="sparqlQuery">SPARQL Query</param> /// <returns></returns> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { if (!this._skipLocalParsing) { //Parse the query locally to validate it and so we can decide what to do //when we receive the Response more easily as we'll know the query type //This also saves us wasting a HttpWebRequest on a malformed query SparqlQueryParser qparser = new SparqlQueryParser(); SparqlQuery q = qparser.ParseFromString(sparqlQuery); switch (q.QueryType) { case SparqlQueryType.Ask: case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: //Some kind of Sparql Result Set this._endpoint.QueryWithResultSet(resultsHandler, sparqlQuery); break; case SparqlQueryType.Construct: case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: //Some kind of Graph this._endpoint.QueryWithResultGraph(rdfHandler, sparqlQuery); break; case SparqlQueryType.Unknown: default: //Error throw new RdfQueryException("Unknown Query Type was used, unable to determine how to process the response"); } } else { //If we're skipping local parsing then we'll need to just make a raw query and process the response using (HttpWebResponse response = this._endpoint.QueryRaw(sparqlQuery)) { try { //Is the Content Type referring to a Sparql Result Set format? ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); sparqlParser.Load(resultsHandler, new StreamReader(response.GetResponseStream())); response.Close(); } catch (RdfParserSelectionException) { //If we get a Parser Selection exception then the Content Type isn't valid for a Sparql Result Set //Is the Content Type referring to a RDF format? IRdfReader rdfParser = MimeTypesHelper.GetParser(response.ContentType); rdfParser.Load(rdfHandler, new StreamReader(response.GetResponseStream())); response.Close(); } } } }
/// <summary> /// Makes a Query where the expected Result is an RDF Graph ie. CONSTRUCT and DESCRIBE Queries /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="sparqlQuery">SPARQL Query String</param> public virtual void QueryWithResultGraph(IRdfHandler handler, String sparqlQuery) { try { //Make the Query using (HttpWebResponse httpResponse = this.QueryInternal(sparqlQuery, this.RdfAcceptHeader)) { //Parse into a Graph based on Content Type String ctype = httpResponse.ContentType; IRdfReader parser = MimeTypesHelper.GetParser(ctype); parser.Load(handler, new StreamReader(httpResponse.GetResponseStream())); httpResponse.Close(); } } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } //Some sort of HTTP Error occurred throw new RdfQueryException("A HTTP Error occurred when trying to make the SPARQL Query, see inner exception for details", webEx); } catch (RdfException) { //Some problem with the RDF or Parsing thereof throw; } }
/// <summary> /// Gets the raw Similarity Graph for the Knowledge Base. /// </summary> /// <param name="number">Number of Similar Individuals.</param> /// <param name="individual">QName of a Individual to find Similar Individuals to.</param> /// <param name="callback">Callback to invoke when the operation completes.</param> /// <param name="state">State to pass to the callback.</param> /// <remarks> /// If the operation succeeds the callback will be invoked normally, if there is an error the callback will be invoked with a instance of <see cref="AsyncError"/> passed as the state which provides access to the error message and the original state passed in. /// </remarks> public void SimilarityRaw(int number, String individual, GraphCallback callback, Object state) { if (number < 1) { throw new RdfReasoningException("Pellet Server requires the number of Similar Individuals to be at least 1"); } String requestUri = _similarityUri + number + "/" + individual; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(MimeTypes.Where(t => !t.Equals("text/json")), MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); try { request.BeginGetResponse(result => { try { using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result)) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); callback(g, state); } } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } callback(null, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state)); } catch (Exception ex) { callback(null, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state)); } }, null); } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } callback(null, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state)); } catch (Exception ex) { callback(null, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state)); } }
/// <summary> /// Gets the Raw Predictions Graph from the Knowledge Base /// </summary> /// <param name="individual">QName of an Individual</param> /// <param name="property">QName of a Property</param> /// <returns></returns> public IGraph PredictRaw(String individual, String property) { String requestUri = _predictUri + individual + "/" + property; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(MimeTypes.Where(t => !t.Equals("text/json")), MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } throw new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server", webEx); } }
/// <summary> /// Loads a Graph from the Protocol Server /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">URI of the Graph to load</param> public virtual void LoadGraph(IRdfHandler handler, String graphUri) { String retrievalUri = this._serviceUri; if (graphUri != null && !graphUri.Equals(String.Empty)) { retrievalUri += "?graph=" + Uri.EscapeDataString(graphUri); } else { retrievalUri += "?default"; } try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(retrievalUri); request.Method = "GET"; request.Accept = MimeTypesHelper.HttpAcceptHeader; request = base.GetProxiedRequest(request); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif //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(); } } catch (WebException webEx) { //If the error is a 404 then return false //Any other error caused the function to throw an error if (webEx.Response != null) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } #endif } throw new RdfStorageException("A HTTP Error occurred while trying to load a Graph from the Store", webEx); } }
/// <summary> /// Loads a Graph from the Store /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">URI of the Graph to load</param> /// <remarks> /// If an empty/null URI is specified then the Default Graph of the Store will be loaded /// </remarks> public void LoadGraph(IRdfHandler handler, String graphUri) { try { HttpWebRequest request; Dictionary <String, String> serviceParams = new Dictionary <string, string>(); String tID = (this._activeTrans == null) ? String.Empty : "/" + this._activeTrans; String requestUri = this._kb + tID + "/query"; SparqlParameterizedString construct = new SparqlParameterizedString(); if (!graphUri.Equals(String.Empty)) { construct.CommandText = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH @graph { ?s ?p ?o } }"; construct.SetUri("graph", UriFactory.Create(graphUri)); } else { construct.CommandText = "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }"; } serviceParams.Add("query", construct.ToString()); request = this.CreateRequest(requestUri, MimeTypesHelper.HttpAcceptHeader, "GET", serviceParams); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); response.Close(); } } catch (WebException webEx) { #if DEBUG if (Options.HttpDebugging) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } } #endif throw new RdfStorageException("A HTTP Error occurred while trying to load a Graph from the Store", webEx); } }
private void btnOpen_Click(object sender, RoutedEventArgs e) { try { Uri u = new Uri(this.txtUri.Text); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(u.ToString()); request.Accept = MimeTypesHelper.HttpAcceptHeader + ",*.*"; String data; using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { data = new StreamReader(response.GetResponseStream()).ReadToEnd(); try { this._parser = MimeTypesHelper.GetParser(response.ContentType); if (this._parser is NTriplesParser) { if (!response.ContentType.Equals("text/plain")) { this._parser = null; } } } catch (RdfParserSelectionException) { //Ignore here as we'll try and set the parser in another way next } response.Close(); } this._data = data; if (this._parser == null) { this._parser = StringParser.GetParser(data); if (this._parser is NTriplesParser) { this._parser = null; } } this._u = u; this.DialogResult = true; this.Close(); } catch (UriFormatException) { MessageBox.Show("You have failed to enter a valid URI", "Invalid URI"); } catch (WebException webEx) { MessageBox.Show("A HTTP error occurred opening the URI: " + webEx.Message, "Open URI Failed"); } catch (Exception ex) { MessageBox.Show("An error occurred while opening the URI: " + ex.Message, "Open URI Failed"); } }
/// <summary> /// Loads a Graph from the Store /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">Uri of the Graph to load</param> /// <remarks>If a Null/Empty Uri is specified then the default graph (statements with no context in Sesame parlance) will be loaded</remarks> public virtual void LoadGraph(IRdfHandler handler, String graphUri) { try { HttpWebRequest request; Dictionary <String, String> serviceParams = new Dictionary <string, string>(); String requestUri = this._repositoriesPrefix + this._store + "/statements"; if (!graphUri.Equals(String.Empty)) { //if (this._fullContextEncoding) //{ serviceParams.Add("context", "<" + graphUri + ">"); //} //else //{ // serviceParams.Add("context", graphUri); //} } request = this.CreateRequest(requestUri, MimeTypesHelper.HttpAcceptHeader, "GET", serviceParams); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); response.Close(); } } catch (WebException webEx) { #if DEBUG if (Options.HttpDebugging) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } } #endif throw new RdfStorageException("A HTTP Error occurred while trying to load a Graph from the Store", webEx); } }
/// <summary> /// Extracts the Graph which comprises the class hierarchy. /// </summary> /// <param name="callback">Callback for when the operation completes.</param> /// <param name="state">State to be passed to the callback.</param> /// <remarks> /// If the operation succeeds the callback will be invoked normally, if there is an error the callback will be invoked with a instance of <see cref="AsyncError"/> passed as the state which provides access to the error message and the original state passed in. /// </remarks> public void Classify(GraphCallback callback, Object state) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Endpoint.Uri); request.Method = Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(MimeTypes, MimeTypesHelper.SupportedRdfMimeTypes); Tools.HttpDebugRequest(request); try { request.BeginGetResponse(result => { try { using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result)) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); callback(g, state); } } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } callback(null, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state)); } catch (Exception ex) { callback(null, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state)); } }, null); } catch (WebException webEx) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } callback(null, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state)); } catch (Exception ex) { callback(null, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state)); } }
/// <summary> /// Makes a Query asynchronously where the expected Result is an RDF Graph ie. CONSTRUCT and DESCRIBE Queries /// </summary> /// <param name="query">SPARQL Query String</param> /// <param name="callback">Callback to invoke when the query completes</param> /// <param name="state">State to pass to the callback</param> public void QueryWithResultGraph(String query, GraphCallback callback, Object state) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Uri); request.Method = "POST"; request.ContentType = MimeTypesHelper.WWWFormURLEncoded; request.Accept = MimeTypesHelper.HttpAcceptHeader; #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif request.BeginGetRequestStream(result => { Stream stream = request.EndGetRequestStream(result); using (StreamWriter writer = new StreamWriter(stream)) { writer.Write("query="); writer.Write(HttpUtility.UrlEncode(query)); foreach (String u in this.DefaultGraphs) { writer.Write("&default-graph-uri="); writer.Write(Uri.EscapeDataString(u)); } foreach (String u in this.NamedGraphs) { writer.Write("&named-graph-uri="); writer.Write(Uri.EscapeDataString(u)); } writer.Close(); } request.BeginGetResponse(innerResult => { HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(innerResult); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); callback(g, state); }, null); }, null); }
private string ParseBody(RdfFormat contentType) { var parser = MimeTypesHelper.GetParser(contentType.MediaTypes.First()); var writer = new WriteToStringHandler(typeof(VDS.RDF.Writing.Formatting.NTriplesFormatter)); using (var reader = new StreamReader(Request.Body)) { parser.Load(writer, reader); } return(writer.ToString()); }
/// <summary> /// Gets the raw Cluster Graph for the Knowledge Base /// </summary> /// <param name="number">Number of Clusters</param> /// <param name="type">QName of a Type to Cluster around</param> /// <returns></returns> public IGraph ClusterRaw(int number, String type) { if (number < 2) { throw new RdfReasoningException("Pellet Server requires the number of Clusters to be at least 2"); } String requestUri = this._clusterUri + number + "/" + type; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = this.Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(this.MimeTypes.Where(t => !t.Equals("text/json")), MimeTypesHelper.SupportedRdfMimeTypes); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } } catch (WebException webEx) { #if DEBUG if (Options.HttpDebugging) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } } #endif throw new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server", webEx); } }
/// <summary> /// Loads a Graph from the Joseki store /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">URI of the Graph to load</param> public void LoadGraph(IRdfHandler handler, String graphUri) { try { HttpWebRequest request; Dictionary <String, String> serviceParams = new Dictionary <string, string>(); String query = "CONSTRUCT {?s ?p ?o}"; if (!graphUri.Equals(String.Empty)) { query += " FROM <" + graphUri.ToString().Replace(">", "\\>") + ">"; } query += " WHERE {?s ?p ?o}"; serviceParams.Add("query", query); request = this.CreateRequest(this._queryService, MimeTypesHelper.HttpAcceptHeader, "GET", serviceParams); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); response.Close(); } } catch (WebException webEx) { #if DEBUG if (Options.HttpDebugging) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } } #endif throw new RdfStorageException("A HTTP Error occurred while communicating with Joseki", webEx); } }
private void DescribeInternal(IRdfHandler handler, String resourceUri, String servicePath) { //Single about param Dictionary <String, String> ps = new Dictionary <string, string>(); ps.Add("about", resourceUri); HttpWebRequest request = null; HttpWebResponse response = null; try { //Get the Request Object request = this.CreateRequest(servicePath, ps); request.Method = "GET"; request.Accept = MimeTypesHelper.HttpAcceptHeader; #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif using (response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif //Get the relevant Parser IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); response.Close(); } } catch (WebException webEx) { if (webEx.Response != null) { //Got a Response so we can analyse the Response Code response = (HttpWebResponse)webEx.Response; int code = (int)response.StatusCode; throw Error(code, webEx); } //Didn't get a Response throw; } }
/// <summary> /// Gets the Graph which can be parsed from the request body. /// </summary> /// <param name="context">HTTP Context.</param> /// <returns></returns> /// <remarks> /// In the event that there is no request body a null will be returned. /// </remarks> protected IGraph ParsePayload(IHttpContext context) { if (context.Request.ContentLength == 0) { return(null); } Graph g = new Graph(); IRdfReader parser = MimeTypesHelper.GetParser(context.Request.ContentType); parser.Load(g, new StreamReader(context.Request.InputStream)); g.NamespaceMap.Clear(); return(g); }
private void ParseResult(TextReader reader) { if (ResultFormat is RdfFormat) { ResultGraph = new Graph(); var parser = MimeTypesHelper.GetParser(ResultFormat.MediaTypes); parser.Load(ResultGraph, reader); } else { ResultSet = new SparqlResultSet(); var parser = MimeTypesHelper.GetSparqlParser(ResultFormat.MediaTypes[0]); parser.Load(ResultSet, reader); } }
protected override void ImportUsingHandler(IRdfHandler handler) { this.Information = "Importing from File " + this._file; try { //Assume a RDF Graph IRdfReader reader = MimeTypesHelper.GetParser(MimeTypesHelper.GetMimeTypes(Path.GetExtension(this._file))); FileLoader.Load(handler, this._file, reader); } catch (RdfParserSelectionException) { //Assume a RDF Dataset FileLoader.LoadDataset(handler, this._file); } }
/// <summary> /// Loads a Graph from the Protocol Server /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">URI of the Graph to load</param> public virtual void LoadGraph(IRdfHandler handler, String graphUri) { String retrievalUri = this._serviceUri; if (graphUri != null && !graphUri.Equals(String.Empty)) { retrievalUri += "?graph=" + Uri.EscapeDataString(graphUri); } else { retrievalUri += "?default"; } try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(retrievalUri); request.Method = "GET"; request.Accept = MimeTypesHelper.HttpAcceptHeader; request = base.ApplyRequestOptions(request); Tools.HttpDebugRequest(request); using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { 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(); } } catch (WebException webEx) { // If the error is a 404 then return // Any other error caused the function to throw an error if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); if (((HttpWebResponse)webEx.Response).StatusCode == HttpStatusCode.NotFound) { return; } } throw StorageHelper.HandleHttpError(webEx, "loading a Graph from"); } }
/// <summary> /// Extracts the Graph which comprises the class hierarchy /// </summary> public IGraph Classify() { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Endpoint.Uri); request.Method = this.Endpoint.HttpMethods.First(); request.Accept = MimeTypesHelper.CustomHttpAcceptHeader(this.MimeTypes, MimeTypesHelper.SupportedRdfMimeTypes); #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugRequest(request); } #endif try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { #if DEBUG if (Options.HttpDebugging) { Tools.HttpDebugResponse(response); } #endif IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } } catch (WebException webEx) { #if DEBUG if (Options.HttpDebugging) { if (webEx.Response != null) { Tools.HttpDebugResponse((HttpWebResponse)webEx.Response); } } #endif throw new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server", webEx); } }
/// <summary> /// Loads the contents of the given File using a RDF Handler using the given RDF Parser /// </summary> /// <param name="handler">RDF Handler to use</param> /// <param name="filename">File to load from</param> /// <param name="parser">Parser to use</param> public static void Load(IRdfHandler handler, String filename, IRdfReader parser) { if (handler == null) { throw new RdfParseException("Cannot read RDF using a null RDF Handler"); } if (filename == null) { throw new RdfParseException("Cannot read RDF from a null File"); } //Try to get a Parser from the File Extension if one isn't explicitly specified if (parser == null) { try { parser = MimeTypesHelper.GetParser(MimeTypesHelper.GetMimeTypes(Path.GetExtension(filename))); RaiseWarning("Selected Parser " + parser.ToString() + " based on file extension, if this is incorrect consider specifying the parser explicitly"); } catch (RdfParserSelectionException) { //If error then we couldn't determine MIME Type from the File Extension RaiseWarning("Unable to select a parser by determining MIME Type from the File Extension"); } } if (parser == null) { //Unable to determine format from File Extension //Read file in locally and use the StringParser to select a parser RaiseWarning("Attempting to select parser based on analysis of the data file, this requires loading the file into memory"); StreamReader reader = new StreamReader(filename); String data = reader.ReadToEnd(); reader.Close(); parser = StringParser.GetParser(data); RaiseWarning("Used the StringParser to guess the parser to use - it guessed " + parser.GetType().Name); parser.Warning += RaiseWarning; parser.Load(handler, new StringReader(data)); } else { //Parser was selected based on File Extension or one was explicitly specified parser.Warning += RaiseWarning; parser.Load(handler, filename); } }
public void ParsingRdfXmlNamespaceAttributes() { Graph g = new Graph(); HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://dbpedia.org/resource/Southampton"); request.Method = "GET"; request.Accept = MimeTypesHelper.HttpAcceptHeader; HttpWebResponse response = (HttpWebResponse)request.GetResponse(); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(g, new StreamReader(response.GetResponseStream())); foreach (Triple t in g.Triples) { Console.WriteLine(t.ToString()); } }
/// <summary> /// Makes a Query asynchronously where the expected Result is an RDF Graph ie. CONSTRUCT and DESCRIBE Queries /// </summary> /// <param name="query">SPARQL Query String</param> /// <param name="handler">RDF Handler</param> /// <param name="callback">Callback to invoke when the query completes</param> /// <param name="state">State to pass to the callback</param> public void QueryWithResultGraph(IRdfHandler handler, String query, QueryCallback callback, Object state) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Uri); request.Method = "POST"; request.ContentType = MimeTypesHelper.WWWFormURLEncoded; request.Accept = this.ResultsAcceptHeader; Tools.HttpDebugRequest(request); request.BeginGetRequestStream(result => { Stream stream = request.EndGetRequestStream(result); using (StreamWriter writer = new StreamWriter(stream)) { writer.Write("query="); writer.Write(HttpUtility.UrlEncode(query)); foreach (String u in this.DefaultGraphs) { writer.Write("&default-graph-uri="); writer.Write(HttpUtility.UrlEncode(u)); } foreach (String u in this.NamedGraphs) { writer.Write("&named-graph-uri="); writer.Write(HttpUtility.UrlEncode(u)); } writer.Close(); } request.BeginGetResponse(innerResult => { HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(innerResult); Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); callback(handler, null, state); }, null); }, null); }
/// <summary> /// Processes a SPARQL Query against the Knowledge Base passing the results to the RDF or Results handler as appropriate /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="sparqlQuery">SPARQL Query</param> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(UriFactory.Create(this._sparqlUri)); using (HttpWebResponse response = endpoint.QueryRaw(sparqlQuery)) { try { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); sparqlParser.Load(resultsHandler, new StreamReader(response.GetResponseStream())); } catch (RdfParserSelectionException) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(rdfHandler, new StreamReader(response.GetResponseStream())); } response.Close(); } }