[tracker/carlosgc/soup3] Add support for building with libsoup3

[Carlos Garcia Campos <carlosgc src gnome org>]

commit c39f93b8a4b3cbd89aa5af642ccb4edeb75c6132
Author: Carlos Garcia Campos <cgarcia igalia com>
Date:   Tue Mar 23 15:59:16 2021 +0100

    Add support for building with libsoup3
    
    Add soup2 build option, enabled by default. When disabled, it builds
    against soup3 instead.

 meson.build                                      |  6 +++
 meson_options.txt                                |  2 +
 src/libtracker-sparql/remote/meson.build         |  8 ++-
 src/libtracker-sparql/remote/tracker-remote.vala | 37 ++++++++++---
 src/libtracker-sparql/tracker-endpoint-http.c    | 68 +++++++++++++++++++++---
 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;
        }