dd4cec577d
Do it even on stable builds as it can help diagnose bugs on releases. Note that the issue we had just know with casing on the build-id would not have been seen by such stderr output anyway. Just in case for future issues.
320 lines
10 KiB
C
320 lines
10 KiB
C
/* GIMP - The GNU Image Manipulation Program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* gimp-update.c
|
|
* Copyright (C) 2019 Jehan
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <glib.h>
|
|
#include <json-glib/json-glib.h>
|
|
#include <stdio.h>
|
|
|
|
#ifndef GIMP_CONSOLE_COMPILATION
|
|
#include <gtk/gtk.h>
|
|
#endif
|
|
|
|
#include "libgimpbase/gimpbase.h"
|
|
|
|
#include "core/core-types.h"
|
|
|
|
#include "config/gimpcoreconfig.h"
|
|
|
|
#ifndef GIMP_CONSOLE_COMPILATION
|
|
#include "dialogs/about-dialog.h"
|
|
#endif
|
|
|
|
#include "gimp-intl.h"
|
|
#include "gimp-update.h"
|
|
#include "gimp-version.h"
|
|
|
|
|
|
static gboolean
|
|
gimp_version_break (const gchar *v,
|
|
gint *major,
|
|
gint *minor,
|
|
gint *micro)
|
|
{
|
|
gchar **versions;
|
|
|
|
*major = 0;
|
|
*minor = 0;
|
|
*micro = 0;
|
|
|
|
if (v == NULL)
|
|
return FALSE;
|
|
|
|
versions = g_strsplit_set (v, ".", 3);
|
|
if (versions[0] != NULL)
|
|
{
|
|
*major = g_ascii_strtoll (versions[0], NULL, 10);
|
|
if (versions[1] != NULL)
|
|
{
|
|
*minor = g_ascii_strtoll (versions[1], NULL, 10);
|
|
if (versions[2] != NULL)
|
|
{
|
|
*micro = g_ascii_strtoll (versions[2], NULL, 10);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
g_strfreev (versions);
|
|
|
|
return (*major > 0);
|
|
}
|
|
|
|
static void
|
|
gimp_check_updates_callback (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GFileInputStream *stream;
|
|
GimpCoreConfig *config = user_data;
|
|
GError *error = NULL;
|
|
|
|
stream = g_file_read_finish (G_FILE (source), result, &error);
|
|
if (stream)
|
|
{
|
|
const gchar *platform;
|
|
const gchar *last_version = NULL;
|
|
const gchar *release_date = NULL;
|
|
JsonParser *parser;
|
|
JsonPath *path;
|
|
JsonNode *result;
|
|
JsonArray *versions;
|
|
JsonArray *builds;
|
|
gint build_revision = 0;
|
|
gint major;
|
|
gint minor;
|
|
gint micro;
|
|
gint i;
|
|
|
|
/* For Windows and macOS, let's look if installers are available.
|
|
* For other platforms, let's just look for source release.
|
|
*/
|
|
if (g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "windows") == 0 ||
|
|
g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "macos") == 0)
|
|
platform = GIMP_BUILD_PLATFORM_FAMILY;
|
|
else
|
|
platform = "source";
|
|
|
|
parser = json_parser_new ();
|
|
if (! json_parser_load_from_stream (parser, G_INPUT_STREAM (stream), NULL, &error))
|
|
{
|
|
g_printerr("%s: parsing of %s failed: %s\n", G_STRFUNC,
|
|
g_file_get_uri (G_FILE (source)), error->message);
|
|
g_clear_object (&stream);
|
|
g_clear_object (&parser);
|
|
g_clear_error (&error);
|
|
|
|
return;
|
|
}
|
|
|
|
path = json_path_new ();
|
|
/* Ideally we could just use Json path filters like this to
|
|
* retrieve only released binaries for a given platform:
|
|
* g_strdup_printf ("$['STABLE'][?(@.%s)]['version']", platform);
|
|
* json_array_get_string_element (result, 0);
|
|
* And that would be it! We'd have our last release for given
|
|
* platform.
|
|
* Unfortunately json-glib does not support filter syntax, so we
|
|
* end up looping through releases.
|
|
*/
|
|
if (! json_path_compile (path, "$['STABLE'][*]", &error))
|
|
{
|
|
#ifdef GIMP_UNSTABLE
|
|
g_printerr("Path compilation failed: %s\n", error->message);
|
|
#endif
|
|
g_clear_object (&stream);
|
|
g_clear_object (&parser);
|
|
g_clear_error (&error);
|
|
|
|
return;
|
|
}
|
|
result = json_path_match (path, json_parser_get_root (parser));
|
|
g_return_if_fail (JSON_NODE_HOLDS_ARRAY (result));
|
|
|
|
versions = json_node_get_array (result);
|
|
for (i = 0; i < (gint) json_array_get_length (versions); i++)
|
|
{
|
|
JsonObject *version;
|
|
|
|
/* Note that we don't actually look for the highest version,
|
|
* but for the highest version for which a build for your
|
|
* platform is available.
|
|
*/
|
|
version = json_array_get_object_element (versions, i);
|
|
if (json_object_has_member (version, platform))
|
|
{
|
|
last_version = json_object_get_string_member (version, "version");
|
|
release_date = json_object_get_string_member (version, "date");
|
|
builds = json_object_get_array_member (version, platform);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If version is not properly parsed, something is wrong with
|
|
* upstream version number or parsing. This should not happen.
|
|
*/
|
|
if (gimp_version_break (last_version, &major, &minor, µ))
|
|
{
|
|
const gchar *build_date = NULL;
|
|
GDateTime *datetime;
|
|
gchar *str;
|
|
|
|
if (major < GIMP_MAJOR_VERSION ||
|
|
(major == GIMP_MAJOR_VERSION && minor < GIMP_MINOR_VERSION) ||
|
|
(major == GIMP_MAJOR_VERSION && minor == GIMP_MINOR_VERSION && micro < GIMP_MICRO_VERSION))
|
|
{
|
|
/* We are using a newer version than last one (somehow). */
|
|
last_version = NULL;
|
|
}
|
|
else if (major == GIMP_MAJOR_VERSION &&
|
|
minor == GIMP_MINOR_VERSION &&
|
|
micro == GIMP_MICRO_VERSION)
|
|
{
|
|
for (i = 0; i < (gint) json_array_get_length (builds); i++)
|
|
{
|
|
const gchar *build_id = NULL;
|
|
JsonObject *build;
|
|
|
|
build = json_array_get_object_element (builds, i);
|
|
if (json_object_has_member (build, "build-id"))
|
|
build_id = json_object_get_string_member (build, "build-id");
|
|
if (g_strcmp0 (build_id, GIMP_BUILD_ID) == 0)
|
|
{
|
|
if (json_object_has_member (build, "revision"))
|
|
build_revision = json_object_get_int_member (build, "revision");
|
|
if (json_object_has_member (build, "date"))
|
|
build_date = json_object_get_string_member (build, "date");
|
|
break;
|
|
}
|
|
}
|
|
if (build_revision <= gimp_version_get_revision ())
|
|
{
|
|
/* Already using the last officially released
|
|
* revision. */
|
|
last_version = NULL;
|
|
}
|
|
}
|
|
str = g_strdup_printf ("%s 00:00:00Z", build_date ? build_date : release_date);
|
|
datetime = g_date_time_new_from_iso8601 (str, NULL);
|
|
g_free (str);
|
|
if (datetime)
|
|
{
|
|
g_object_set (config,
|
|
"check-update-timestamp", g_get_real_time() / G_USEC_PER_SEC,
|
|
"last-release-timestamp", g_date_time_to_unix (datetime),
|
|
"last-known-release", last_version,
|
|
"last-revision", build_revision,
|
|
NULL);
|
|
g_date_time_unref (datetime);
|
|
}
|
|
}
|
|
|
|
g_object_unref (path);
|
|
g_object_unref (parser);
|
|
g_object_unref (stream);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_update_about_dialog (GimpCoreConfig *config,
|
|
const GParamSpec *pspec,
|
|
gpointer user_data)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (config,
|
|
(GCallback) gimp_update_about_dialog,
|
|
NULL);
|
|
|
|
if (config->last_known_release != NULL)
|
|
{
|
|
#ifndef GIMP_CONSOLE_COMPILATION
|
|
gtk_widget_show (about_dialog_create (config));
|
|
#else
|
|
g_warning (_("A new version of GIMP (%s) was released.\n"
|
|
"It is recommended to update."),
|
|
config->last_known_release);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* gimp_update_auto_check:
|
|
* @config:
|
|
*
|
|
* Run the check for newer versions of GIMP if conditions are right.
|
|
*/
|
|
gboolean
|
|
gimp_update_auto_check (GimpCoreConfig *config)
|
|
{
|
|
gint64 prev_update_timestamp;
|
|
gint64 current_timestamp;
|
|
|
|
/* Builds with update check deactivated just always return FALSE. */
|
|
#ifdef CHECK_UPDATE
|
|
if (! config->check_updates)
|
|
#endif
|
|
return FALSE;
|
|
|
|
g_object_get (config,
|
|
"check-update-timestamp", &prev_update_timestamp,
|
|
NULL);
|
|
current_timestamp = g_get_real_time() / G_USEC_PER_SEC;
|
|
|
|
/* Get rid of invalid saved timestamps. */
|
|
if (prev_update_timestamp > current_timestamp)
|
|
prev_update_timestamp = -1;
|
|
|
|
#ifndef GIMP_UNSTABLE
|
|
/* Do not check more than once a week. */
|
|
if (current_timestamp - prev_update_timestamp < 3600L * 24L * 7L)
|
|
return FALSE;
|
|
#endif
|
|
|
|
g_signal_connect (config, "notify::last-known-release",
|
|
(GCallback) gimp_update_about_dialog,
|
|
NULL);
|
|
|
|
return gimp_update_check (config);
|
|
}
|
|
|
|
/*
|
|
* gimp_update_check:
|
|
* @config:
|
|
*
|
|
* Run the check for newer versions of GIMP inconditionnally.
|
|
*/
|
|
gboolean
|
|
gimp_update_check (GimpCoreConfig *config)
|
|
{
|
|
GFile *gimp_versions;
|
|
|
|
#ifdef GIMP_UNSTABLE
|
|
if (g_getenv ("GIMP_DEV_VERSIONS_JSON"))
|
|
gimp_versions = g_file_new_for_path (g_getenv ("GIMP_DEV_VERSIONS_JSON"));
|
|
else
|
|
gimp_versions = g_file_new_for_uri ("https://testing.gimp.org/gimp_versions.json");
|
|
#else
|
|
gimp_versions = g_file_new_for_uri ("https://gimp.org/gimp_versions.json");
|
|
#endif
|
|
g_file_read_async (gimp_versions, 0, NULL, gimp_check_updates_callback, config);
|
|
g_object_unref (gimp_versions);
|
|
|
|
return TRUE;
|
|
}
|