Add support for building with libsoup3carlosgc/soup3

Add soup2 build option, enabled by default. When disabled, it builds
against soup3 instead.

5 files changed, 105 insertions, 16 deletions

diff --git a/meson.build b/meson.build
index efa6d83b4..8b9823e6a 100644
--- a/meson.build
+++ b/meson.build
@@ -52,6 +52,12 @@ libxml2 = dependency('libxml-2.0', version: '> 2.6')
 sqlite = dependency('sqlite3', version: '>' + sqlite_required)
 dbus = dependency('dbus-1')
 
+if get_option('soup2')
+  libsoup = dependency('libsoup-2.4', version: '> 2.40', required: true)
+else
+  libsoup = dependency('libsoup-3.0', version: '>= 2.99.2', required: true)
+endif
+
 libmath = cc.find_library('m', required: false)
 
 if get_option('man')
diff --git a/meson_options.txt b/meson_options.txt
index 99c569502..46e9c130f 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -26,3 +26,5 @@ option('test_utils_dir', type: 'string', value: '',
        description: 'Directory to install trackertestutils Python package (or empty to use the default)')
 option('tests_tap_protocol', type: 'boolean', value: false,
        description: 'Whether to enable TAP protocol on tests')
+option('soup2', type: 'boolean', value: true,
+       description: 'Whether to build with libsoup2')
diff --git a/src/libtracker-sparql/remote/meson.build b/src/libtracker-sparql/remote/meson.build
index f4d589d61..916b72a8a 100644
--- a/src/libtracker-sparql/remote/meson.build
+++ b/src/libtracker-sparql/remote/meson.build
@@ -7,13 +7,19 @@ sources = [
     '../../libtracker-common/libtracker-common.vapi'
 ]
 
+if get_option('soup2')
+  vala_defines = ['--define=SOUP2']
+else
+  vala_defines = []
+endif
+
 libtracker_remote = static_library('tracker-remote', sources,
     dependencies: tracker_remote_dependencies + [tracker_common_dep, tracker_sparql_intermediate_dep],
     c_args: tracker_c_args + [
         '-include', 'config.h',
         '-include', 'libtracker-sparql/tracker-private.h',
     ],
-    vala_args: [
+    vala_args: vala_defines + [
         '--debug',
         '--pkg', 'posix',
         # FIXME: Meson has code to add --target-glib automatically, but it
diff --git a/src/libtracker-sparql/remote/tracker-remote.vala b/src/libtracker-sparql/remote/tracker-remote.vala
index 206c237fc..50dc612f3 100644
--- a/src/libtracker-sparql/remote/tracker-remote.vala
+++ b/src/libtracker-sparql/remote/tracker-remote.vala
@@ -39,7 +39,11 @@ public class Tracker.Remote.Connection : Tracker.Sparql.Connection {
 	private Soup.Message create_request (string sparql) {
 		var uri = _base_uri + "?query=" + sparql;
 		var message = new Soup.Message ("GET", uri);
+#if SOUP2
 		var headers = message.request_headers;
+#else
+                var headers = message.get_request_headers();
+#endif
 
 		headers.append ("User-Agent", USER_AGENT);
 		headers.append ("Accept", JSON_TYPE);
@@ -48,15 +52,20 @@ public class Tracker.Remote.Connection : Tracker.Sparql.Connection {
 		return message;
 	}
 
-	private Sparql.Cursor create_cursor (Soup.Message message) throws GLib.Error, Sparql.Error {
-		string document = (string) message.response_body.flatten ().data;
+	private Sparql.Cursor create_cursor (Soup.Message message, string document) throws GLib.Error, Sparql.Error {
+#if SOUP2
+                var status_code = message.status_code;
+                var headers = message.response_headers;
+#else
+                var status_code = message.get_status();
+                var headers = message.get_response_headers();
+#endif
 
-		if (message.status_code != Soup.Status.OK) {
+		if (status_code != Soup.Status.OK) {
 			throw new Sparql.Error.UNSUPPORTED ("Unhandled status code %u, document is: %s",
-			                                    message.status_code, document);
+			                                    status_code, document);
 		}
 
-		var headers = message.response_headers;
 		var content_type = headers.get_content_type (null);
 		long length = document.length;
 
@@ -72,20 +81,32 @@ public class Tracker.Remote.Connection : Tracker.Sparql.Connection {
 	public override Sparql.Cursor query (string sparql, Cancellable? cancellable) throws GLib.Error, Sparql.Error, IOError {
 		var message = create_request (sparql);
 
+#if SOUP2
 		_session.send_message (message);
+#else
+                var body = _session.send_and_read (message);
+#endif
 
 		if (cancellable != null && cancellable.is_cancelled ())
 			throw new IOError.CANCELLED ("Operation was cancelled");
 
-		return create_cursor (message);
+#if SOUP2
+                return create_cursor (message, (string) message.response_body.flatten ().data);
+#else
+                return create_cursor (message, (string) body.get_data());
+#endif
 	}
 
 	public async override Sparql.Cursor query_async (string sparql, Cancellable? cancellable) throws GLib.Error, Sparql.Error, IOError {
 		var message = create_request (sparql);
 
+#if SOUP2
 		yield _session.send_async (message, cancellable);
-
-		return create_cursor (message);
+                return create_cursor (message, (string) message.response_body.flatten ().data);
+#else
+                var body = yield _session.send_and_read_async (message, GLib.Priority.DEFAULT, cancellable);
+                return create_cursor (message, (string) body.get_data());
+#endif
 	}
 
 	public override void close () {
diff --git a/src/libtracker-sparql/tracker-endpoint-http.c b/src/libtracker-sparql/tracker-endpoint-http.c
index de231ca59..5aa82b03d 100644
--- a/src/libtracker-sparql/tracker-endpoint-http.c
+++ b/src/libtracker-sparql/tracker-endpoint-http.c
@@ -41,7 +41,11 @@ struct _TrackerEndpointHttp {
 
 typedef struct {
 	TrackerEndpoint *endpoint;
+#if SOUP_CHECK_VERSION (2, 99, 2)
+        SoupServerMessage *message;
+#else
 	SoupMessage *message;
+#endif
 	GInputStream *istream;
 	GTask *task;
 	TrackerSerializerFormat format;
@@ -90,9 +94,11 @@ handle_request_in_thread (GTask        *task,
 	GError *error = NULL;
 	gssize count;
 
-	g_object_get (request->message,
-	              "response-body", &message_body,
-	              NULL);
+#if SOUP_CHECK_VERSION (2, 99, 2)
+        message_body = soup_server_message_get_response_body (request->message);
+#else
+        message_body = request->message->response_body;
+#endif
 
 	while (!finished) {
 		count = g_input_stream_read (request->istream,
@@ -127,12 +133,22 @@ request_finished_cb (GObject      *object,
 	endpoint_http = TRACKER_ENDPOINT_HTTP (request->endpoint);
 
 	if (!g_task_propagate_boolean (G_TASK (result), &error)) {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (request->message, 500,
+                                                error ? error->message :
+                                                "No error message");
+#else
 		soup_message_set_status_full (request->message, 500,
 		                              error ? error->message :
 		                              "No error message");
+#endif
 		g_clear_error (&error);
 	} else {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (request->message, 200, NULL);
+#else
 		soup_message_set_status (request->message, 200);
+#endif
 	}
 
 	soup_server_unpause_message (endpoint_http->server, request->message);
@@ -153,7 +169,11 @@ query_async_cb (GObject      *object,
 	cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (object),
 	                                                 result, &error);
 	if (error) {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (request->message, 500, error->message);
+#else
 		soup_message_set_status_full (request->message, 500, error->message);
+#endif
 		soup_server_unpause_message (endpoint_http->server, request->message);
 		request_free (request);
 		return;
@@ -167,16 +187,25 @@ query_async_cb (GObject      *object,
 	g_task_run_in_thread (request->task, handle_request_in_thread);
 }
 
+#if SOUP_CHECK_VERSION (2, 99, 2)
+static gboolean
+pick_format (SoupServerMessage       *message,
+             TrackerSerializerFormat *format)
+#else
 static gboolean
 pick_format (SoupMessage             *message,
              TrackerSerializerFormat *format)
+#endif
 {
 	SoupMessageHeaders *request_headers, *response_headers;
 
-	g_object_get (message,
-	              "request-headers", &request_headers,
-	              "response-headers", &response_headers,
-	              NULL);
+#if SOUP_CHECK_VERSION (2, 99, 2)
+        request_headers = soup_server_message_get_request_headers (message);
+        response_headers = soup_server_message_get_response_headers (message);
+#else
+        request_headers = message->request_headers;
+        response_headers = message->response_headers;
+#endif
 
 	if (soup_message_headers_header_contains (request_headers, "Accept", JSON_TYPE)) {
 		soup_message_headers_set_content_type (response_headers, JSON_TYPE, NULL);
@@ -193,6 +222,14 @@ pick_format (SoupMessage             *message,
 	return FALSE;
 }
 
+#if SOUP_CHECK_VERSION (2, 99, 2)
+static void
+server_callback (SoupServer        *server,
+	         SoupServerMessage *message,
+                 const char        *path,
+	         GHashTable        *query,
+                 gpointer           user_data)
+#else
 static void
 server_callback (SoupServer        *server,
                  SoupMessage       *message,
@@ -200,6 +237,7 @@ server_callback (SoupServer        *server,
                  GHashTable        *query,
                  SoupClientContext *client,
                  gpointer           user_data)
+#endif
 {
 	TrackerEndpoint *endpoint = user_data;
 	TrackerSparqlConnection *conn;
@@ -209,25 +247,41 @@ server_callback (SoupServer        *server,
 	const gchar *sparql;
 	Request *request;
 
+#if SOUP_CHECK_VERSION (2, 99, 2)
+        remote_address = soup_server_message_get_remote_address (message);
+#else
 	remote_address = soup_client_context_get_remote_address (client);
+#endif
 	if (remote_address) {
 		g_signal_emit (endpoint, signals[BLOCK_REMOTE_ADDRESS], 0,
 		               remote_address, &block);
 	}
 
 	if (block) {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (message, 500, "Remote address disallowed");
+#else
 		soup_message_set_status_full (message, 500, "Remote address disallowed");
+#endif
 		return;
 	}
 
 	sparql = g_hash_table_lookup (query, "query");
 	if (!sparql) {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (message, 500, "No query given");
+#else
 		soup_message_set_status_full (message, 500, "No query given");
+#endif
 		return;
 	}
 
 	if (!pick_format (message, &format)) {
+#if SOUP_CHECK_VERSION (2, 99, 2)
+                soup_server_message_set_status (message, 500, "No recognized accepted formats");
+#else
 		soup_message_set_status_full (message, 500, "No recognized accepted formats");
+#endif
 		return;
 	}