dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/gimp-update.c

473 lines
15 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-09 02:08:49 +08: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 20:41:59 +08: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-09 02:08:49 +08: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 20:41:59 +08: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-09 02:08:49 +08:00
#include "gimp-intl.h"
#include "gimp-update.h"
app: store the revision number in a data file. I realized having the revision as a build number is the wrong idea as it implies packagers will have to rebuild GIMP for just a revision. Yet very often revision may just be data change or dependency fix/update without rebuild needed (i.e. no ABI change). Instead let's keep this package information as a file 'gimp-release' (inspired by /etc/os-release and other /etc/*-release files of distributions).
2020-02-14 06:59:46 +08:00
#include "gimp-version.h"
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-09 02:08:49 +08:00
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
static gboolean gimp_update_known (GimpCoreConfig *config,
const gchar *last_version,
gint64 release_timestamp,
gint build_revision,
const gchar *comment);
static gboolean gimp_version_break (const gchar *v,
gint *major,
gint *minor,
gint *micro);
static void gimp_check_updates_callback (GObject *source,
GAsyncResult *result,
gpointer user_data);
static void gimp_update_about_dialog (GimpCoreConfig *config,
const GParamSpec *pspec,
gpointer user_data);
/* Private Functions */
/**
* gimp_update_known:
* @config:
* @last_version:
* @release_timestamp: must be non-zero is @last_version is not %NULL.
* @build_revision:
* @build_comment:
*
* Compare @last_version with currently running version. If the checked
* version is more recent than running version, then @config properties
* are updated appropriately (which may trigger a dialog depending on
* update policy settings).
* If @last_version is %NULL, the currently stored "last known release"
* is compared. Even if we haven't made any new remote checks, it is
* important to always compare again stored last release, otherwise we
* might warn of the same current version, or worse an older version.
*
* Returns: %TRUE is @last_version (or stored last known release if
* @last_version was %NULL) is newer than running version.
*/
static gboolean
gimp_update_known (GimpCoreConfig *config,
const gchar *last_version,
gint64 release_timestamp,
gint build_revision,
const gchar *build_comment)
{
gboolean new_check = (last_version != NULL);
gint major;
gint minor;
gint micro;
if (last_version && release_timestamp == 0)
{
/* I don't exit with a g_return_val_if_fail() assert because this
* is not necessarily a code bug. It may be data issues. So let's
* just return with an error printed on stderr.
*/
g_printerr ("%s: version %s with no release dates.\n",
G_STRFUNC, last_version);
return FALSE;
}
if (last_version == NULL)
{
last_version = config->last_known_release;
release_timestamp = config->last_release_timestamp;
build_revision = config->last_revision;
build_comment = config->last_release_comment;
}
if (last_version)
{
if (gimp_version_break (last_version, &major, &minor, &micro))
{
if (/* We are using a newer version than last check. This could
* happen if updating the config files without having
* re-checked the remote JSON file.
*/
(major < GIMP_MAJOR_VERSION ||
(major == GIMP_MAJOR_VERSION && minor < GIMP_MINOR_VERSION) ||
(major == GIMP_MAJOR_VERSION && minor == GIMP_MINOR_VERSION && micro < GIMP_MICRO_VERSION)) ||
/* Already using the last officially released
* revision. */
(major == GIMP_MAJOR_VERSION &&
minor == GIMP_MINOR_VERSION &&
micro == GIMP_MICRO_VERSION &&
build_revision <= gimp_version_get_revision ()))
{
last_version = NULL;
}
}
else
{
/* If version is not properly parsed, something is wrong with
* upstream version number or parsing. This should not happen.
*/
g_printerr ("%s: version not properly formatted: %s\n",
G_STRFUNC, last_version);
return FALSE;
}
}
if (last_version == NULL)
{
release_timestamp = 0;
build_revision = 0;
build_comment = NULL;
}
if (new_check)
g_object_set (config,
"check-update-timestamp", g_get_real_time() / G_USEC_PER_SEC,
NULL);
g_object_set (config,
"last-release-timestamp", release_timestamp,
"last-known-release", last_version,
"last-revision", build_revision,
"last-release-comment", build_comment,
NULL);
/* Are we running an old GIMP? */
return (last_version != NULL);
}
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-09 02:08:49 +08:00
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)
{
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
GimpCoreConfig *config = user_data;
char *file_contents = NULL;
gsize file_length = 0;
GError *error = NULL;
if (g_file_load_contents_finish (G_FILE (source), result,
&file_contents, &file_length,
NULL, &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-09 02:08:49 +08:00
{
app: use GIMP_BUILD_PLATFORM_FAMILY instead of GIMP_BUILD_PLATFORM. I didn't realize it because the meson build was returning 'windows' for GIMP_BUILD_PLATFORM when I cross-built with Mingw-w64. But in the autotools, it was storing "mingw32", which would not compare with our gimp_versions.json. Therefore in GIMP 2.10.16, the version update check would have worked, but not the revision check. This fixes the problem.
2020-02-23 02:54:15 +08:00
const gchar *platform;
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
const gchar *last_version = NULL;
const gchar *release_date = NULL;
const gchar *build_comment = NULL;
gint64 release_timestamp = 0;
gint build_revision = 0;
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-24 05:08:33 +08:00
JsonParser *parser;
JsonPath *path;
JsonNode *result;
JsonArray *versions;
gint i;
/* For Windows and macOS, let's look if installers are available.
* For other platforms, let's just look for source release.
*/
app: use GIMP_BUILD_PLATFORM_FAMILY instead of GIMP_BUILD_PLATFORM. I didn't realize it because the meson build was returning 'windows' for GIMP_BUILD_PLATFORM when I cross-built with Mingw-w64. But in the autotools, it was storing "mingw32", which would not compare with our gimp_versions.json. Therefore in GIMP 2.10.16, the version update check would have worked, but not the revision check. This fixes the problem.
2020-02-23 02:54:15 +08:00
if (g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "windows") == 0 ||
g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "macos") == 0)
platform = GIMP_BUILD_PLATFORM_FAMILY;
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-24 05:08:33 +08:00
else
app: use GIMP_BUILD_PLATFORM_FAMILY instead of GIMP_BUILD_PLATFORM. I didn't realize it because the meson build was returning 'windows' for GIMP_BUILD_PLATFORM when I cross-built with Mingw-w64. But in the autotools, it was storing "mingw32", which would not compare with our gimp_versions.json. Therefore in GIMP 2.10.16, the version update check would have worked, but not the revision check. This fixes the problem.
2020-02-23 02:54:15 +08:00
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-09 02:08:49 +08:00
parser = json_parser_new ();
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
if (! json_parser_load_from_data (parser, file_contents, file_length, &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-09 02:08:49 +08:00
{
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
g_printerr ("%s: parsing of %s failed: %s\n", G_STRFUNC,
g_file_get_uri (G_FILE (source)), error->message);
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
g_free (file_contents);
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-09 02:08:49 +08:00
g_clear_object (&parser);
app: better error management. - Clear the GError when relevant. - Check result of json_path_compile() just in case. - Print some error on stderr when parsing of gimp_versions.json fails (which should never happen on releases but would help during development).
2020-01-26 22:10:44 +08:00
g_clear_error (&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-09 02:08:49 +08:00
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-24 05:08:33 +08:00
/* Ideally we could just use Json path filters like this to
* retrieve only released binaries for a given platform:
app: use GIMP_BUILD_PLATFORM_FAMILY instead of GIMP_BUILD_PLATFORM. I didn't realize it because the meson build was returning 'windows' for GIMP_BUILD_PLATFORM when I cross-built with Mingw-w64. But in the autotools, it was storing "mingw32", which would not compare with our gimp_versions.json. Therefore in GIMP 2.10.16, the version update check would have worked, but not the revision check. This fixes the problem.
2020-02-23 02:54:15 +08:00
* g_strdup_printf ("$['STABLE'][?(@.%s)]['version']", platform);
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-24 05:08:33 +08:00
* 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.
*/
app: better error management. - Clear the GError when relevant. - Check result of json_path_compile() just in case. - Print some error on stderr when parsing of gimp_versions.json fails (which should never happen on releases but would help during development).
2020-01-26 22:10:44 +08:00
if (! json_path_compile (path, "$['STABLE'][*]", &error))
{
#ifdef GIMP_UNSTABLE
g_printerr("Path compilation failed: %s\n", error->message);
#endif
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
g_free (file_contents);
app: better error management. - Clear the GError when relevant. - Check result of json_path_compile() just in case. - Print some error on stderr when parsing of gimp_versions.json fails (which should never happen on releases but would help during development).
2020-01-26 22:10:44 +08:00
g_clear_object (&parser);
g_clear_error (&error);
return;
}
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-09 02:08:49 +08: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-24 05:08:33 +08: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-09 02:08:49 +08:00
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
/* Note that we don't actually look for the highest version,
* but for the highest version for which a build for your
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
* platform (and optional build-id) is available.
*
* So we loop through the version list then the build array
* and break at first compatible release, since JSON arrays
* are ordered.
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08: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-24 05:08:33 +08:00
version = json_array_get_object_element (versions, i);
app: use GIMP_BUILD_PLATFORM_FAMILY instead of GIMP_BUILD_PLATFORM. I didn't realize it because the meson build was returning 'windows' for GIMP_BUILD_PLATFORM when I cross-built with Mingw-w64. But in the autotools, it was storing "mingw32", which would not compare with our gimp_versions.json. Therefore in GIMP 2.10.16, the version update check would have worked, but not the revision check. This fixes the problem.
2020-02-23 02:54:15 +08:00
if (json_object_has_member (version, platform))
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-24 05:08:33 +08:00
{
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
JsonArray *builds;
gint j;
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-09 02:08:49 +08:00
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
builds = json_object_get_array_member (version, platform);
for (j = 0; j < (gint) json_array_get_length (builds); j++)
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
{
const gchar *build_id = NULL;
JsonObject *build;
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
build = json_array_get_object_element (builds, j);
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
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)
{
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
/* Release date is the build date if any set,
* otherwise the main version release date.
*/
if (json_object_has_member (build, "date"))
release_date = json_object_get_string_member (build, "date");
else
release_date = json_object_get_string_member (version, "date");
/* These are optional data. */
app: accept "revision" and "date" fields to be absent on a build... ... object in the gimp_versions.json file.
2020-02-07 05:15:11 +08:00
if (json_object_has_member (build, "revision"))
build_revision = json_object_get_int_member (build, "revision");
app: let's display the release comment in update notification… … when there is one such comment.
2020-03-30 21:37:34 +08:00
if (json_object_has_member (build, "comment"))
build_comment = json_object_get_string_member (build, "comment");
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
break;
}
}
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
if (release_date)
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
{
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
last_version = json_object_get_string_member (version, "version");
break;
app: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
}
}
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
}
if (last_version && release_date)
{
GDateTime *datetime;
gchar *str;
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-03 06:09:23 +08:00
datetime = g_date_time_new_from_iso8601 (str, NULL);
g_free (str);
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
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-03 06:09:23 +08:00
if (datetime)
{
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
release_timestamp = g_date_time_to_unix (datetime);
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-03 06:09:23 +08:00
g_date_time_unref (datetime);
}
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
else
{
/* JSON file data bug. */
g_printerr ("%s: release date for version %s not properly formatted: %s\n",
G_STRFUNC, last_version, release_date);
last_version = NULL;
release_date = NULL;
build_revision = 0;
build_comment = NULL;
}
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-09 02:08:49 +08:00
}
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
gimp_update_known (config, last_version, release_timestamp, build_revision, build_comment);
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-09 02:08:49 +08:00
g_object_unref (path);
g_object_unref (parser);
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
g_free (file_contents);
}
else
{
g_printerr("%s: loading of %s failed: %s\n", G_STRFUNC,
g_file_get_uri (G_FILE (source)), error->message);
g_clear_error (&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-09 02:08:49 +08:00
}
}
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 20:41:59 +08: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
}
}
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
/* Public Functions */
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 17:51:59 +08:00
/*
* gimp_update_auto_check:
* @config:
*
* Run the check for newer versions of GIMP if conditions are right.
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
*
* Returns: %TRUE if a check was actually run.
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 17:51:59 +08:00
*/
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-09 02:08:49 +08: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 17:51:59 +08: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-09 02:08:49 +08:00
{
gint64 prev_update_timestamp;
gint64 current_timestamp;
app, configure: new --disable-check-update option at configuration. Allows to disable the automatic update check at startup. I believe some packagers will want such options, in particular on Linux distribution (where they control their own release schedule and won't want GIMP to pop new version warning up because they have been slow to update their package). Note that it is still possible to query version checks manually in the about dialog, but the automatic check/popup is gone with this option.
2020-02-07 04:15:43 +08:00
/* Builds with update check deactivated just always return FALSE. */
#ifdef CHECK_UPDATE
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-09 02:08:49 +08:00
if (! config->check_updates)
app, configure: new --disable-check-update option at configuration. Allows to disable the automatic update check at startup. I believe some packagers will want such options, in particular on Linux distribution (where they control their own release schedule and won't want GIMP to pop new version warning up because they have been slow to update their package). Note that it is still possible to query version checks manually in the about dialog, but the automatic check/popup is gone with this option.
2020-02-07 04:15:43 +08:00
#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-09 02:08:49 +08:00
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-29 03:28:13 +08: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-09 02:08:49 +08: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-29 03:28:13 +08: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-09 02:08:49 +08: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-29 03:28:13 +08: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-09 02:08:49 +08: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-29 03:28:13 +08: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 20:41:59 +08:00
g_signal_connect (config, "notify::last-known-release",
(GCallback) gimp_update_about_dialog,
NULL);
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
gimp_update_check (config);
return TRUE;
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 17:51:59 +08:00
}
/*
* gimp_update_check:
* @config:
*
* Run the check for newer versions of GIMP inconditionnally.
*/
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
void
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 17:51:59 +08:00
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-29 03:28:13 +08: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
Issue #5623: https://gimp.org/gimp_versions.json is redirected… … to www.gimp.org.
2020-09-09 03:12:34 +08:00
gimp_versions = g_file_new_for_uri ("https://www.gimp.org/gimp_versions.json");
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-29 03:28:13 +08:00
#endif
Issue #4904: GIMP startup SLOW due to failed access to… … oscp-router0[12].gnome.org. The file was opened asynchronously through g_file_read_async() but the actually reading from a GFileInputStream was actually done in the callback, in the main thread. So it may be possible that file is accessible but connection is very slow or non-reliable and actual reading would block the main process. I am assuming this is what may have happened for this reporter. Instead let's use g_file_load_contents_async() which does the file opening, reading and closing all in the asynchronous task, hence would not slow down anything even if the remote resource is unavailable or connection is very slow.
2020-04-04 01:24:10 +08:00
g_file_load_contents_async (gimp_versions, NULL, gimp_check_updates_callback, 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-09 02:08:49 +08:00
g_object_unref (gimp_versions);
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
}
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-09 02:08:49 +08:00
Issue #4777: "New version available" after update. The About dialog refreshes the release information relatively to currently running version before being displayed. No check of the remote JSON file is done, it only verifies whether any stored released version/revision is not same (or even lower) than the actually running version. Indeed existence of a stored release means that a newer version exists at check time only. On later run, this stored information may have become deprecated.
2020-10-17 00:04:15 +08:00
/*
* gimp_update_refresh:
* @config:
*
* Do not execute a remote check, but refresh the known release data as
* it may be outdated.
*/
void
gimp_update_refresh (GimpCoreConfig *config)
{
gimp_update_known (config, NULL, 0, 0, NULL);
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-09 02:08:49 +08:00
}