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

332 lines
11 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
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;
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 *last_version = NULL;
const gchar *release_date = NULL;
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;
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
JsonArray *builds;
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
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.
*/
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
{
app: print gimp_versions.json parsing error on stderr. Do it even on stable builds as it can help diagnose bugs on releases. Note that the issue we had just know with casing on the build-id would not have been seen by such stderr output anyway. Just in case for future issues. (cherry picked from commit dd4cec577dd146720ccebd99e33618177773d5d2)
2020-03-30 20:40:20 +08:00
g_printerr("%s: parsing of %s failed: %s\n", G_STRFUNC,
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_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
* platform is available.
*/
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
{
last_version = json_object_get_string_member (version, "version");
release_date = json_object_get_string_member (version, "date");
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
builds = json_object_get_array_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
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-09 02:08:49 +08: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: let's display the release comment in update notification… … when there is one such comment.
2020-03-30 21:37:34 +08:00
const gchar *build_date = NULL;
const gchar *build_comment = NULL;
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
GDateTime *datetime;
gchar *str;
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
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 (major < GIMP_MAJOR_VERSION ||
(major == GIMP_MAJOR_VERSION && minor < GIMP_MINOR_VERSION) ||
(major == GIMP_MAJOR_VERSION && minor == GIMP_MINOR_VERSION && micro < GIMP_MICRO_VERSION))
{
/* We are using a newer version than last one (somehow). */
last_version = NULL;
}
else if (major == GIMP_MAJOR_VERSION &&
minor == GIMP_MINOR_VERSION &&
micro == GIMP_MICRO_VERSION)
{
for (i = 0; i < (gint) json_array_get_length (builds); i++)
{
const gchar *build_id = NULL;
JsonObject *build;
build = json_array_get_object_element (builds, i);
if (json_object_has_member (build, "build-id"))
build_id = json_object_get_string_member (build, "build-id");
if (g_strcmp0 (build_id, GIMP_BUILD_ID) == 0)
{
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");
if (json_object_has_member (build, "date"))
build_date = json_object_get_string_member (build, "date");
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;
}
}
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
if (build_revision <= gimp_version_get_revision ())
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
{
/* Already using the last officially released
* revision. */
last_version = NULL;
}
}
str = g_strdup_printf ("%s 00:00:00Z", build_date ? build_date : 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);
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),
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
"last-known-release", last_version,
"last-revision", 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
"last-release-comment", build_comment,
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
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-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
}
}
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.
*/
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);
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
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-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
gimp_versions = g_file_new_for_uri ("https://gimp.org/gimp_versions.json");
#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);
return TRUE;
}