You are viewing a plain text version of this content. The canonical link for it is here.
Posted to pr@jena.apache.org by GitBox <gi...@apache.org> on 2021/12/16 09:09:47 UTC
[GitHub] [jena] afs opened a new pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
afs opened a new pull request #1133:
URL: https://github.com/apache/jena/pull/1133
This is part 1 of a 2 change. This PR copies the Apache HttpClient code used by jen-jdb into that subsystem and puts in a compile-time dependency on Apache HttpClient into jena-jdbc-driver-remote.
The second part removes the legacy classes from jena-arq. See [JENA-2221](https://issues.apache.org/jira/browse/JENA-2221).
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] rvesse commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
rvesse commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-996041751
@afs Wasn't volunteering you, long time since I looked at this code and wondered if there was anything in particular that meant that it wasn't an option
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] kinow commented on a change in pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
kinow commented on a change in pull request #1133:
URL: https://github.com/apache/jena/pull/1133#discussion_r773039972
##########
File path: jena-jdbc/jena-jdbc-driver-remote/src/main/java/org/apache/jena/jdbc/remote/http/QueryEngineHTTP.java
##########
@@ -0,0 +1,870 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.jdbc.remote.http;
+
+import java.io.ByteArrayInputStream ;
+import java.io.IOException;
+import java.io.InputStream ;
+import java.util.ArrayList ;
+import java.util.Iterator ;
+import java.util.List ;
+import java.util.Map ;
+import java.util.concurrent.TimeUnit ;
+
+import org.apache.http.client.HttpClient ;
+import org.apache.http.client.protocol.HttpClientContext;
+import org.apache.http.protocol.HttpContext ;
+import org.apache.jena.atlas.RuntimeIOException;
+import org.apache.jena.atlas.io.IO ;
+import org.apache.jena.atlas.json.JSON;
+import org.apache.jena.atlas.json.JsonArray;
+import org.apache.jena.atlas.json.JsonObject;
+import org.apache.jena.atlas.json.JsonValue;
+import org.apache.jena.atlas.lib.Pair ;
+import org.apache.jena.graph.Triple ;
+import org.apache.jena.query.* ;
+import org.apache.jena.rdf.model.Model ;
+import org.apache.jena.riot.*;
+import org.apache.jena.riot.resultset.ResultSetLang;
+import org.apache.jena.riot.resultset.ResultSetReaderRegistry;
+import org.apache.jena.sparql.ARQException ;
+import org.apache.jena.sparql.core.Quad;
+import org.apache.jena.sparql.engine.ResultSetCheckCondition ;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.engine.http.HttpParams;
+import org.apache.jena.sparql.engine.http.Params;
+import org.apache.jena.sparql.engine.http.QueryExceptionHTTP;
+import org.apache.jena.sparql.graph.GraphFactory ;
+import org.apache.jena.sparql.resultset.ResultSetException;
+import org.apache.jena.sparql.util.Context ;
+import org.slf4j.Logger ;
+import org.slf4j.LoggerFactory ;
+
+/**
+ * A query execution implementation where queries are executed against a remote
+ * service
+ * @deprecated Use the QueryExecutionHTTP builder. {@code QueryExecutionHTTP.create()....execute()}
+ */
+@Deprecated
+public class QueryEngineHTTP implements QueryExecution {
+ private static Logger log = LoggerFactory.getLogger(QueryEngineHTTP.class);
+
+ public static final String QUERY_MIME_TYPE = WebContent.contentTypeSPARQLQuery;
+ private final Query query;
+ private final String queryString;
+ private final String service;
+ private final Context context;
+
+ // Params
+ private Params params = null;
+
+ // Protocol
+ private List<String> defaultGraphURIs = new ArrayList<>();
+ private List<String> namedGraphURIs = new ArrayList<>();
+ private HttpClient client;
+ private HttpContext httpContext;
+
+ private boolean closed = false;
+
+ // Timeouts
+ private long connectTimeout = -1;
+ private TimeUnit connectTimeoutUnit = TimeUnit.MILLISECONDS;
+ private long readTimeout = -1;
+ private TimeUnit readTimeoutUnit = TimeUnit.MILLISECONDS;
+
+ // Compression Support
+ // Note that compression setting is used in HttpQuery.
+ /** See {@link HttpQuery} */
+ private boolean allowCompression = true;
+
+ // Updates default headers, same variables.
+ private String selectContentType = WebContent.defaultSparqlResultsHeader;
+ private String askContentType = WebContent.defaultSparqlAskHeader;
+ private String modelContentType = WebContent.defaultGraphAcceptHeader;
+
+// private String constructContentType = WebContent.defaultGraphAcceptHeader;
+ private String datasetContentType = WebContent.defaultDatasetAcceptHeader;
+
+ // If this is non-null, it overrides the ???ContentType choice.
+ private String acceptHeader = null;
+
+
+ // Received content type
+ private String httpResponseContentType = null ;
+ /**
+ * Supported content types for SELECT queries
+ */
+ public static String[] supportedSelectContentTypes = new String[] { WebContent.contentTypeResultsXML,
+ WebContent.contentTypeResultsJSON, WebContent.contentTypeTextTSV, WebContent.contentTypeTextCSV,
+ WebContent.contentTypeResultsThrift};
+ /**
+ * Supported content types for ASK queries
+ */
+ public static String[] supportedAskContentTypes = new String[] { WebContent.contentTypeResultsXML,
+ WebContent.contentTypeResultsJSON, WebContent.contentTypeTextTSV, WebContent.contentTypeTextCSV };
+
+ // Releasing HTTP input streams is important. We remember this for SELECT,
+ // and will close when the engine is closed
+ private InputStream retainedConnection = null;
+
+ public QueryEngineHTTP(String serviceURI, Query query) {
+ this(serviceURI, query, null, null);
+ }
+
+ public QueryEngineHTTP(String serviceURI, Query query, HttpClient client) {
+ this(serviceURI, query, client, null);
+ }
+
+ public QueryEngineHTTP(String serviceURI, Query query, HttpClient client, HttpContext httpContext) {
+ this(serviceURI, query, query.toString(), client, httpContext);
+ }
+
+ public QueryEngineHTTP(String serviceURI, String queryString) {
+ this(serviceURI, queryString, null, null);
+ }
+
+ public QueryEngineHTTP(String serviceURI, String queryString, HttpClient client) {
+ this(serviceURI, queryString, client, null);
+ }
+
+ public QueryEngineHTTP(String serviceURI, String queryString, HttpClient client, HttpContext httpContext) {
+ this(serviceURI, null, queryString, client, httpContext);
+ }
+
+ private QueryEngineHTTP(String serviceURI, Query query, String queryString, HttpClient client, HttpContext httpContext) {
+ this.query = query;
+ this.queryString = queryString;
+ this.service = serviceURI;
+ this.context = ARQ.getContext().copy();
+
+ // Apply service configuration if relevant
+ applyServiceConfig(serviceURI, this);
+
+ // Don't want to overwrite client config we may have picked up from
+ // service context in the parent constructor if the specified
+ // client is null
+ if (client != null) setClient(client);
+ if (httpContext != null) setHttpContext(httpContext);
+ }
+
+ /**
+ * <p>
+ * Helper method which applies configuration from the Context to the query
+ * engine if a service context exists for the given URI
+ * </p>
+ * <p>
+ * Based off proposed patch for JENA-405 but modified to apply all relevant
+ * configuration, this is in part also based off of the private
+ * {@code configureQuery()} method of the {@link Service_AHC} class though it
+ * omits parameter merging since that will be done automatically whenever
+ * the {@link QueryEngineHTTP} instance makes a query for remote submission.
+ * </p>
+ *
+ * @param serviceURI
+ * Service URI
+ */
+ private static void applyServiceConfig(String serviceURI, QueryEngineHTTP engine) {
+ if (engine.context == null)
+ return;
+
+ @SuppressWarnings("unchecked")
+ Map<String, Context> serviceContextMap = (Map<String, Context>) engine.context.get(Service_AHC.serviceContext);
+ if (serviceContextMap != null && serviceContextMap.containsKey(serviceURI)) {
+ Context serviceContext = serviceContextMap.get(serviceURI);
+ if (log.isDebugEnabled())
+ log.debug("Endpoint URI {} has SERVICE Context: {} ", serviceURI, serviceContext);
+
+ // Apply behavioural options
+ engine.setAllowCompression(serviceContext.isTrueOrUndef(Service_AHC.queryCompression));
+ applyServiceTimeouts(engine, serviceContext);
+
+ // Apply context-supplied client settings
+ HttpClient client = serviceContext.get(Service_AHC.queryClient);
+
+ if (client != null) {
+ if (log.isDebugEnabled())
+ log.debug("Using context-supplied HTTP client for endpoint URI {}", serviceURI);
+ engine.setClient(client);
+ }
+ }
+ }
+
+ /**
+ * Applies context provided timeouts to the given engine
+ *
+ * @param engine
+ * Engine
+ * @param context
+ * Context
+ */
+ private static void applyServiceTimeouts(QueryEngineHTTP engine, Context context) {
+ if (context.isDefined(Service_AHC.queryTimeout)) {
+ Object obj = context.get(Service_AHC.queryTimeout);
+ if (obj instanceof Number) {
+ int x = ((Number) obj).intValue();
+ engine.setTimeout(-1, x);
+ } else if (obj instanceof String) {
+ try {
+ String str = obj.toString();
+ if (str.contains(",")) {
+ String[] a = str.split(",");
+ int connect = Integer.parseInt(a[0]);
+ int read = Integer.parseInt(a[1]);
+ engine.setTimeout(read, connect);
+ } else {
+ int x = Integer.parseInt(str);
+ engine.setTimeout(-1, x);
+ }
+ } catch (NumberFormatException ex) {
+ throw new QueryExecException("Can't interpret string for timeout: " + obj);
+ }
+ } else {
+ throw new QueryExecException("Can't interpret timeout: " + obj);
+ }
+ }
+ }
+
+ // public void setParams(Params params)
+ // { this.params = params ; }
+
+ @Override
+ public void setInitialBinding(QuerySolution binding) {
+ throw new UnsupportedOperationException(
+ "Initial bindings not supported for remote queries, consider using a ParameterizedSparqlString to prepare a query for remote execution");
+ }
+
+ @Override
+ public void setInitialBinding(Binding binding) {
+ throw new UnsupportedOperationException(
+ "Initial bindings not supported for remote queries, consider using a ParameterizedSparqlString to prepare a query for remote execution");
+ }
+ /**
+ * @param defaultGraphURIs
+ * The defaultGraphURIs to set.
+ */
+ public void setDefaultGraphURIs(List<String> defaultGraphURIs) {
+ this.defaultGraphURIs = defaultGraphURIs;
+ }
+
+ /**
+ * @param namedGraphURIs
+ * The namedGraphURIs to set.
+ */
+ public void setNamedGraphURIs(List<String> namedGraphURIs) {
+ this.namedGraphURIs = namedGraphURIs;
+ }
+
+ /**
+ * Sets whether the HTTP requests will permit compressed encoding
+ */
+ public void setAllowCompression(boolean allowed) {
+ allowCompression = allowed;
+ }
+
+ public void addParam(String field, String value) {
+ if (params == null)
+ params = new Params();
+ params.addParam(field, value);
+ }
+
+ /**
+ * @param defaultGraph
+ * The defaultGraph to add.
+ */
+ public void addDefaultGraph(String defaultGraph) {
+ if (defaultGraphURIs == null)
+ defaultGraphURIs = new ArrayList<>();
+ defaultGraphURIs.add(defaultGraph);
+ }
+
+ /**
+ * @param name
+ * The URI to add.
+ */
+ public void addNamedGraph(String name) {
+ if (namedGraphURIs == null)
+ namedGraphURIs = new ArrayList<>();
+ namedGraphURIs.add(name);
+ }
+
+ /**
+ * Sets the HTTP client to use, if none is set then the default
+ * client is used.
+ *
+ * @param client
+ * HTTP client
+ */
+ public void setClient(HttpClient client) {
+ this.client = client;
+ }
+
+ /**
+ * Get the HTTP client in use, if none is set then null.
+ *
+ * @return client HTTP client
+ */
+ public HttpClient getClient() {
+ return client;
+ }
+
+ /**
+ * Sets the HTTP context to use, if none is set then the default context is used.
+ *
+ * @param context HTTP context
+ */
+ public void setHttpContext(HttpContext context) {
+ this.httpContext = context;
+ }
+
+ /**
+ * Get the HTTP context in use, if none is set then null.
+ *
+ * @return the {@code HttpContext} in scope
+ */
+ public HttpContext getHttpContext() {
+ return httpContext;
+ }
+
+ /** The Content-Type response header received (null before the remote operation is attempted). */
+ public String getHttpResponseContentType() {
+ return httpResponseContentType;
+ }
+
+ @Override
+ public ResultSet execSelect() {
+ checkNotClosed() ;
+ ResultSet rs = execResultSetInner() ;
+ return new ResultSetCheckCondition(rs, this) ;
+ }
+
+ private ResultSet execResultSetInner() {
+ HttpQuery httpQuery = makeHttpQuery();
+ httpQuery.setAccept(chooseAcceptHeader(acceptHeader, selectContentType));
+ InputStream in = httpQuery.exec();
+
+ if (false) {
+ byte b[] = IO.readWholeFile(in);
+ String str = new String(b);
+ System.out.println(str);
+ in = new ByteArrayInputStream(b);
+ }
+
+ retainedConnection = in; // This will be closed on close()
+
+ // Don't assume the endpoint actually gives back the
+ // content type we asked for
+ String actualContentType = httpQuery.getContentType();
+ httpResponseContentType = actualContentType;
+
+ // If the server fails to return a Content-Type then we will assume
+ // the server returned the type we asked for
+ if (actualContentType == null || actualContentType.equals("")) {
+ actualContentType = selectContentType;
+ }
+
+ // Map to lang, with pragmatic alternatives.
+ Lang lang = WebContent.contentTypeToLangResultSet(actualContentType);
+ if ( lang == null )
+ throw new QueryException("Endpoint returned Content-Type: " + actualContentType + " which is not recognized for SELECT queries");
+ if ( !ResultSetReaderRegistry.isRegistered(lang) )
+ throw new QueryException("Endpoint returned Content-Type: " + actualContentType + " which is not supported for SELECT queries");
+ // This returns a streaming result set for some formats.
+ // Do not close the InputStream at this point.
+
+ ResultSet result = ResultSetMgr.read(in, lang);
+ return result;
+ }
+
+ private static String chooseAcceptHeader(String acceptHeader, String contentType) {
+ if ( acceptHeader != null )
+ return acceptHeader;
+ return contentType;
+ }
+
+ @Override
+ public Model execConstruct() {
+ return execConstruct(GraphFactory.makeJenaDefaultModel());
+ }
+
+ @Override
+ public Model execConstruct(Model model) {
+ return execModel(model);
+ }
+
+ @Override
+ public Iterator<Triple> execConstructTriples() {
+ return execTriples();
+ }
+
+ @Override
+ public Iterator<Quad> execConstructQuads(){
+ return execQuads();
+ }
+
+ @Override
+ public Dataset execConstructDataset(){
+ return execConstructDataset(DatasetFactory.createTxnMem());
+ }
+
+ @Override
+ public Dataset execConstructDataset(Dataset dataset){
+ return execDataset(dataset) ;
+ }
+
+ @Override
+ public Model execDescribe() {
+ return execDescribe(GraphFactory.makeJenaDefaultModel());
+ }
+
+ @Override
+ public Model execDescribe(Model model) {
+ return execModel(model);
+ }
+
+ @Override
+ public Iterator<Triple> execDescribeTriples() {
+ return execTriples();
+ }
+
+ private Model execModel(Model model) {
+ Pair<InputStream, Lang> p = execConstructWorker(modelContentType) ;
+ try(InputStream in = p.getLeft()) {
+ Lang lang = p.getRight() ;
+ RDFDataMgr.read(model, in, lang);
+ } catch (IOException ex) { IO.exception(ex); }
+ finally { this.close(); }
+ return model;
+ }
+
+ private Dataset execDataset(Dataset dataset) {
+ Pair<InputStream, Lang> p = execConstructWorker(datasetContentType);
+ try(InputStream in = p.getLeft()) {
+ Lang lang = p.getRight() ;
+ RDFDataMgr.read(dataset, in, lang);
+ } catch (IOException ex) { IO.exception(ex); }
+ finally { this.close(); }
+ return dataset;
+ }
+
+ private Iterator<Triple> execTriples() {
+ Pair<InputStream, Lang> p = execConstructWorker(modelContentType) ;
+ InputStream in = p.getLeft() ;
+ Lang lang = p.getRight() ;
+ // Base URI?
+ return RDFDataMgr.createIteratorTriples(in, lang, null);
+ }
+
+ private Iterator<Quad> execQuads() {
+ Pair<InputStream, Lang> p = execConstructWorker(datasetContentType) ;
+ InputStream in = p.getLeft() ;
+ Lang lang = p.getRight() ;
+ // Base URI?
+ return RDFDataMgr.createIteratorQuads(in, lang, null);
+ }
+
+ private Pair<InputStream, Lang> execConstructWorker(String contentType) {
+ checkNotClosed() ;
+ HttpQuery httpQuery = makeHttpQuery();
+ httpQuery.setAccept(chooseAcceptHeader(acceptHeader, contentType));
+ InputStream in = httpQuery.exec();
+
+ // Don't assume the endpoint actually gives back the content type we
+ // asked for
+ String actualContentType = httpQuery.getContentType();
+ httpResponseContentType = actualContentType;
+
+ // If the server fails to return a Content-Type then we will assume
+ // the server returned the type we asked for
+ if (actualContentType == null || actualContentType.equals("")) {
+ actualContentType = WebContent.defaultDatasetAcceptHeader;
+ }
+ Lang lang = RDFLanguages.contentTypeToLang(actualContentType);
+ if ( ! RDFLanguages.isQuads(lang) && ! RDFLanguages.isTriples(lang) )
+ throw new QueryException("Endpoint returned Content Type: "
+ + actualContentType
+ + " which is not a valid RDF syntax");
+ return Pair.create(in, lang) ;
+ }
+
+ @Override
+ public boolean execAsk() {
+ checkNotClosed() ;
+ HttpQuery httpQuery = makeHttpQuery();
+ httpQuery.setAccept(chooseAcceptHeader(acceptHeader, askContentType));
+ try(InputStream in = httpQuery.exec()) {
+ // Don't assume the endpoint actually gives back the content type we
+ // asked for
+ String actualContentType = httpQuery.getContentType();
+ httpResponseContentType = actualContentType;
+
+ // If the server fails to return a Content-Type then we will assume
+ // the server returned the type we asked for
+ if (actualContentType == null || actualContentType.equals("")) {
+ actualContentType = askContentType;
+ }
+
+ Lang lang = RDFLanguages.contentTypeToLang(actualContentType);
+ if ( lang == null ) {
+ // Any specials :
+ // application/xml for application/sparql-results+xml
+ // application/json for application/sparql-results+json
+ if (actualContentType.equals(WebContent.contentTypeXML))
+ lang = ResultSetLang.RS_XML;
+ else if ( actualContentType.equals(WebContent.contentTypeJSON))
+ lang = ResultSetLang.RS_JSON;
+ }
+ if ( lang == null )
+ throw new QueryException("Endpoint returned Content-Type: " + actualContentType + " which is not supported for ASK queries");
+ Boolean result = ResultSetMgr.readBoolean(in, lang);
+ return result;
+ } catch (ResultSetException e) {
+ log.warn("Returned content is not a boolean result", e);
+ throw e;
+ } catch (QueryExceptionHTTP e) {
+ throw e ;
+ }
+ catch (java.io.IOException e) {
+ log.warn("Failed to close connection", e);
+ return false ;
+ }
+ finally { this.close(); }
+ }
+
+ @Override
+ public JsonArray execJson()
+ {
+ checkNotClosed();
+ HttpQuery httpQuery = makeHttpQuery();
+ httpQuery.setAccept(WebContent.contentTypeJSON);
+ JsonArray result = new JsonArray();
+ try(InputStream in = httpQuery.exec()) {
+ JsonValue v = JSON.parseAny(in);
+ if ( ! v.isArray() )
+ throw new QueryExecException("Return from a JSON query isn't an array");
+ result = v.getAsArray();
+ } catch (IOException e) { IO.exception(e); }
+ finally { this.close(); }
+ return result;
+ }
+
+ @Override
+ public Iterator<JsonObject> execJsonItems()
+ {
+ // Non-streaming.
+ // TODO Integrate with the JSON parser to stream the results.
+ JsonArray array = execJson().getAsArray();
+ List<JsonObject> x = new ArrayList<>(array.size());
+ array.forEach(elt->{
+ if ( ! elt.isObject())
+ throw new QueryExecException("Item in an array from a JSON query isn't an object");
+ x.add(elt.getAsObject());
+ });
+ return x.iterator();
+ }
+
+ private void checkNotClosed() {
+ if ( closed )
+ throw new QueryExecException("HTTP QueryExecution has been closed") ;
+ }
+
+ @Override
+ public Context getContext() {
+ return context;
+ }
+
+ @Override
+ public Dataset getDataset() {
+ return null;
+ }
+
+ // This may be null - if we were created form a query string,
+ // we don't guarantee to parse it so we let through non-SPARQL
+ // extensions to the far end.
+ @Override
+ public Query getQuery() {
+ if ( query != null )
+ return query;
+ if ( queryString != null ) {
+ // Object not created with a Query object, may be because there is forgein
+ // syntax in the query or may be because the queystrign was available and the app
Review comment:
s/queystrign/querystring
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] afs merged pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
afs merged pull request #1133:
URL: https://github.com/apache/jena/pull/1133
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] afs commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
afs commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-996619669
I'd be surprised if it couldn't be done - it's not like the protocols have changed.
It is two main/src/ classes, looks routine. More changes in the tests which do client setup and auth stuff.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] afs commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
afs commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-995705626
IMO it's not a blocker, it's an ideal that takes work; I'm not offering to do it for this PR.
It will have some impact on configuration and use, especially around authentication. How much does that matter?
I don't know anything about jena-jdbc users, nor have a sense of the upgrade tail so have no view into the impact or benefit.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] afs commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
afs commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-995582384
@rvesse This is the jena-jdbc only changes does as copies of classes to make it easier to discuss and review. PR #1134 does the actual removal of code from jena-arq.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] afs commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
afs commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-998700122
Noted. The companion PR is based off this one so change here affects that as well. (AKA needs rebase).
I'm running some of the bots to make sure the first batch of PRs today went in OK.
I'll put this in separately, if I may, in a bunch of "misc" - a collection of small things that don't change functionality that get noticed in passing.
(Or we might even get the jena-jdbc code updated and this AHC code removed by the release ... bit of a "maybe" on that)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org
[GitHub] [jena] rvesse commented on pull request #1133: JENA-2220: Isolate Apache HTTP Client usage in jena-jdbc
Posted by GitBox <gi...@apache.org>.
rvesse commented on pull request #1133:
URL: https://github.com/apache/jena/pull/1133#issuecomment-995604717
Okay, would it be better to transition these modules over to the new JDK support as well?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: pr-unsubscribe@jena.apache.org
For additional commands, e-mail: pr-help@jena.apache.org