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

584 lines
18 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);
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
static gboolean gimp_update_get_highest (JsonParser *parser,
gchar **highest_version,
gint64 *release_timestamp,
gint *build_revision,
gchar **build_comment,
gboolean unstable);
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 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);
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
static gboolean gimp_version_break (const gchar *v,
gint *major,
gint *minor,
gint *micro);
static gint gimp_version_cmp (const gchar *v1,
const gchar *v2);
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
/* 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);
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;
}
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
if (last_version &&
(/* 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.
*/
gimp_version_cmp (last_version, NULL) < 0 ||
/* Already using the last officially released
* revision. */
(gimp_version_cmp (last_version, NULL) == 0 &&
build_revision <= gimp_version_get_revision ())))
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
last_version = 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
}
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
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
gimp_update_get_highest (JsonParser *parser,
gchar **highest_version,
gint64 *release_timestamp,
gint *build_revision,
gchar **build_comment,
gboolean 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
{
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
JsonPath *path;
JsonNode *result;
JsonArray *versions;
const gchar *platform;
const gchar *path_str;
const gchar *release_date = NULL;
GError *error = NULL;
gint i;
g_return_val_if_fail (highest_version != NULL, FALSE);
g_return_val_if_fail (release_timestamp != NULL, FALSE);
g_return_val_if_fail (build_revision != NULL, FALSE);
g_return_val_if_fail (build_comment != NULL, FALSE);
*highest_version = NULL;
*release_timestamp = 0;
*build_revision = 0;
*build_comment = NULL;
if (unstable)
path_str = "$['DEVELOPMENT'][*]";
else
path_str = "$['STABLE'][*]";
/* For Windows and macOS, let's look if installers are available.
* For other platforms, let's just look for source release.
*/
if (g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "windows") == 0 ||
g_strcmp0 (GIMP_BUILD_PLATFORM_FAMILY, "macos") == 0)
platform = GIMP_BUILD_PLATFORM_FAMILY;
else
platform = "source";
path = json_path_new ();
/* Ideally we could just use Json path filters like this to
* retrieve only released binaries for a given platform:
* g_strdup_printf ("$['STABLE'][?(@.%s)]['version']", platform);
* json_array_get_string_element (result, 0);
* And that would be it! We'd have our last release for given
* platform.
* Unfortunately json-glib does not support filter syntax, so we
* end up looping through releases.
*/
if (! json_path_compile (path, path_str, &error))
{
g_warning ("%s: path compilation failed: %s\n",
G_STRFUNC, error->message);
g_clear_error (&error);
g_object_unref (path);
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
return FALSE;
}
result = json_path_match (path, json_parser_get_root (parser));
if (! JSON_NODE_HOLDS_ARRAY (result))
{
g_printerr ("%s: match for \"%s\" is not a JSON array.\n",
G_STRFUNC, path_str);
g_object_unref (path);
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
return FALSE;
}
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
versions = json_node_get_array (result);
for (i = 0; i < (gint) json_array_get_length (versions); i++)
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
JsonObject *version;
/* Note that we don't actually look for the highest version,
* but for the highest version for which a build for your
* platform (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.
*/
version = json_array_get_object_element (versions, i);
if (json_object_has_member (version, platform))
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
JsonArray *builds;
gint j;
builds = json_object_get_array_member (version, platform);
for (j = 0; j < (gint) json_array_get_length (builds); 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
{
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
const gchar *build_id = NULL;
JsonObject *build;
build = json_array_get_object_element (builds, j);
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 ||
g_strcmp0 (platform, "source") == 0)
{
/* 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. */
if (json_object_has_member (build, "revision"))
*build_revision = json_object_get_int_member (build, "revision");
if (json_object_has_member (build, "comment"))
*build_comment = g_strdup (json_object_get_string_member (build, "comment"));
break;
}
}
if (release_date)
{
*highest_version = g_strdup (json_object_get_string_member (version, "version"));
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
}
}
}
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
if (*highest_version && *release_date)
{
GDateTime *datetime;
gchar *str;
str = g_strdup_printf ("%s 00:00:00Z", release_date);
datetime = g_date_time_new_from_iso8601 (str, NULL);
g_free (str);
if (datetime)
{
*release_timestamp = g_date_time_to_unix (datetime);
g_date_time_unref (datetime);
}
else
{
/* JSON file data bug. */
g_printerr ("%s: release date for version %s not properly formatted: %s\n",
G_STRFUNC, *highest_version, release_date);
g_clear_pointer (highest_version, g_free);
g_clear_pointer (build_comment, g_free);
*build_revision = 0;
}
}
json_node_unref (result);
g_object_unref (path);
return (*highest_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 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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
JsonParser *parser;
gchar *last_version = NULL;
gchar *build_comment = 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
gint64 release_timestamp = 0;
gint build_revision = 0;
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;
}
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
gimp_update_get_highest (parser, &last_version, &release_timestamp,
&build_revision, &build_comment, FALSE);
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
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
#ifdef GIMP_UNSTABLE
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
{
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
gchar *dev_version = NULL;
gchar *dev_comment = NULL;
gint64 dev_timestamp = 0;
gint dev_revision = 0;
gimp_update_get_highest (parser, &dev_version, &dev_timestamp,
&dev_revision, &dev_comment, TRUE);
if (dev_version)
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
{
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
if (! last_version || gimp_version_cmp (dev_version, last_version) > 0)
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
g_clear_pointer (&last_version, g_free);
g_clear_pointer (&build_comment, g_free);
last_version = dev_version;
build_comment = dev_comment;
release_timestamp = dev_timestamp;
build_revision = dev_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
}
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
else
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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
g_clear_pointer (&dev_version, g_free);
g_clear_pointer (&dev_comment, g_free);
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
}
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
#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
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
app: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +08:00
g_clear_pointer (&last_version, g_free);
g_clear_pointer (&build_comment, g_free);
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 (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: unstable versions will check available development releases. Stable versions (i.e. minor version number even, e.g. 2.10.22) will only look for higher stable releases. But for unstable versions, we will want to look up the development releases too. So for instance GIMP 2.99.2 will warn if the development version 2.99.4 has been released, but also if the stable version 3.0.0 has been released (whatever is the highest, which is the stable version in this example).
2020-10-22 22:11:20 +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);
}
/**
* gimp_version_cmp:
* @v1: a string representing a version, ex. "2.10.22".
* @v2: a string representing another version, ex. "2.99.2".
*
* If @v2 is %NULL, @v1 is compared to the currently running version.
*
* Returns: an integer less than, equal to, or greater than zero if @v1
* is found to represent a version respectively, lower than,
* matching, or greater than @v2.
*/
static gint
gimp_version_cmp (const gchar *v1,
const gchar *v2)
{
gint major1;
gint minor1;
gint micro1;
gint major2 = GIMP_MAJOR_VERSION;
gint minor2 = GIMP_MINOR_VERSION;
gint micro2 = GIMP_MICRO_VERSION;
g_return_val_if_fail (v1 != NULL, -1);
if (! gimp_version_break (v1, &major1, &minor1, &micro1))
{
/* 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, v1);
return -1;
}
if (v2 && ! gimp_version_break (v2, &major2, &minor2, &micro2))
{
g_printerr ("%s: version not properly formatted: %s\n",
G_STRFUNC, v2);
return 1;
}
if (major1 == major2 && minor1 == minor2 && micro1 == micro2)
return 0;
else if (major1 > major2 ||
(major1 == major2 && minor1 > minor2) ||
(major1 == major2 && minor1 == minor2 && micro1 > micro2))
return 1;
else
return -1;
}
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
}