procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 09:53:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/app/gimp-update.c

263 lines
7.7 KiB
C
Raw Normal View History

app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
/* 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>
app: show the About dialog at startup when a new version is available. This about dialog will complain an explicit message about the new version and a link button to go to the download page.
2019-12-29 13:41:59 +01:00
#ifndef GIMP_CONSOLE_COMPILATION
#include <gtk/gtk.h>
#endif
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
#include "libgimpbase/gimpbase.h"
#include "core/core-types.h"
#include "config/gimpcoreconfig.h"
app: show the About dialog at startup when a new version is available. This about dialog will complain an explicit message about the new version and a link button to go to the download page.
2019-12-29 13:41:59 +01:00
#ifndef GIMP_CONSOLE_COMPILATION
#include "dialogs/about-dialog.h"
#endif
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
#include "gimp-intl.h"
#include "gimp-update.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)
{
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-23 22:08:33 +01:00
const gchar *build_platform;
const gchar *last_version = NULL;
const gchar *release_date = NULL;
JsonParser *parser;
JsonPath *path;
JsonNode *result;
JsonArray *versions;
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, "windows") == 0 ||
g_strcmp0 (GIMP_BUILD_PLATFORM, "macos") == 0)
build_platform = GIMP_BUILD_PLATFORM;
else
build_platform = "source";
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
parser = json_parser_new ();
if (! json_parser_load_from_stream (parser, G_INPUT_STREAM (stream), NULL, &error))
{
g_clear_object (&stream);
g_clear_object (&parser);
return;
}
path = json_path_new ();
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-23 22:08:33 +01:00
/* 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']", build_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.
*/
json_path_compile (path, "$['STABLE'][*]", &error);
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
result = json_path_match (path, json_parser_get_root (parser));
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-23 22:08:33 +01:00
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;
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-23 22:08:33 +01:00
version = json_array_get_object_element (versions, i);
if (json_object_has_member (version, build_platform))
{
last_version = json_object_get_string_member (version, "version");
release_date = json_object_get_string_member (version, "date");
break;
}
}
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
/* 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, &micro))
{
app: parse the release date for the last release. I was mistakenly using the date of the last check, not the release date.
2020-01-02 23:09:23 +01:00
GDateTime *datetime;
gchar *str;
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-23 22:08:33 +01:00
str = g_strdup_printf ("%s 00:00:00Z", release_date);
app: parse the release date for the last release. I was mistakenly using the date of the last check, not the release date.
2020-01-02 23:09:23 +01:00
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",
(major > GIMP_MAJOR_VERSION ||
(major == GIMP_MAJOR_VERSION && minor > GIMP_MINOR_VERSION) ||
(major == GIMP_MAJOR_VERSION && minor == GIMP_MINOR_VERSION && micro > GIMP_MICRO_VERSION)) ?
last_version : NULL,
NULL);
g_date_time_unref (datetime);
}
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
}
g_object_unref (path);
g_object_unref (parser);
g_object_unref (stream);
}
}
app: show the About dialog at startup when a new version is available. This about dialog will complain an explicit message about the new version and a link button to go to the download page.
2019-12-29 13:41:59 +01:00
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
}
}
app: add alternative "Check for updates" button in the About dialog. When an update is available, a big frame is visible, proposing to go to the download page. Now a button is also available to explicitly request for an update check in other cases (bypassing the wait delay for a future startup).
2019-12-29 10:51:59 +01:00
/*
* gimp_update_auto_check:
* @config:
*
* Run the check for newer versions of GIMP if conditions are right.
*/
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
gboolean
app: add alternative "Check for updates" button in the About dialog. When an update is available, a big frame is visible, proposing to go to the download page. Now a button is also available to explicitly request for an update check in other cases (bypassing the wait delay for a future startup).
2019-12-29 10:51:59 +01:00
gimp_update_auto_check (GimpCoreConfig *config)
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
{
gint64 prev_update_timestamp;
gint64 current_timestamp;
if (! config->check_updates)
return FALSE;
g_object_get (config,
"check-update-timestamp", &prev_update_timestamp,
NULL);
app: make gimp_versions.json parsing easier to test. First, let's make the check happen at each startup on unstable (still once a week on stable). Second, make it parse gimp.org's gimp_versions.json on stable, but testing's one on unstable and also check environment variable GIMP_DEV_VERSIONS_JSON (unstable only) to allow setting a local path (allowing to tweak the file and test various cases). Unrelated to testing, some improvements: - save a timestamp in seconds (really no need to keep microseconds precision here). - just in case, check that the saved timestamp is not in the future.
2019-12-28 20:28:13 +01:00
current_timestamp = g_get_real_time() / G_USEC_PER_SEC;
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
app: make gimp_versions.json parsing easier to test. First, let's make the check happen at each startup on unstable (still once a week on stable). Second, make it parse gimp.org's gimp_versions.json on stable, but testing's one on unstable and also check environment variable GIMP_DEV_VERSIONS_JSON (unstable only) to allow setting a local path (allowing to tweak the file and test various cases). Unrelated to testing, some improvements: - save a timestamp in seconds (really no need to keep microseconds precision here). - just in case, check that the saved timestamp is not in the future.
2019-12-28 20:28:13 +01:00
/* Get rid of invalid saved timestamps. */
if (prev_update_timestamp > current_timestamp)
prev_update_timestamp = -1;
#ifndef GIMP_UNSTABLE
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
/* Do not check more than once a week. */
app: make gimp_versions.json parsing easier to test. First, let's make the check happen at each startup on unstable (still once a week on stable). Second, make it parse gimp.org's gimp_versions.json on stable, but testing's one on unstable and also check environment variable GIMP_DEV_VERSIONS_JSON (unstable only) to allow setting a local path (allowing to tweak the file and test various cases). Unrelated to testing, some improvements: - save a timestamp in seconds (really no need to keep microseconds precision here). - just in case, check that the saved timestamp is not in the future.
2019-12-28 20:28:13 +01:00
if (current_timestamp - prev_update_timestamp < 3600L * 24L * 7L)
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
return FALSE;
app: make gimp_versions.json parsing easier to test. First, let's make the check happen at each startup on unstable (still once a week on stable). Second, make it parse gimp.org's gimp_versions.json on stable, but testing's one on unstable and also check environment variable GIMP_DEV_VERSIONS_JSON (unstable only) to allow setting a local path (allowing to tweak the file and test various cases). Unrelated to testing, some improvements: - save a timestamp in seconds (really no need to keep microseconds precision here). - just in case, check that the saved timestamp is not in the future.
2019-12-28 20:28:13 +01:00
#endif
app: show the About dialog at startup when a new version is available. This about dialog will complain an explicit message about the new version and a link button to go to the download page.
2019-12-29 13:41:59 +01:00
g_signal_connect (config, "notify::last-known-release",
(GCallback) gimp_update_about_dialog,
NULL);
app: add alternative "Check for updates" button in the About dialog. When an update is available, a big frame is visible, proposing to go to the download page. Now a button is also available to explicitly request for an update check in other cases (bypassing the wait delay for a future startup).
2019-12-29 10:51:59 +01:00
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;
app: make gimp_versions.json parsing easier to test. First, let's make the check happen at each startup on unstable (still once a week on stable). Second, make it parse gimp.org's gimp_versions.json on stable, but testing's one on unstable and also check environment variable GIMP_DEV_VERSIONS_JSON (unstable only) to allow setting a local path (allowing to tweak the file and test various cases). Unrelated to testing, some improvements: - save a timestamp in seconds (really no need to keep microseconds precision here). - just in case, check that the saved timestamp is not in the future.
2019-12-28 20:28:13 +01:00
#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
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-08 19:08:49 +01:00
g_file_read_async (gimp_versions, 0, NULL, gimp_check_updates_callback, config);
g_object_unref (gimp_versions);
return TRUE;
}
Reference in a new issue Copy permalink