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

319 lines
9.9 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"
static gboolean
gimp_version_break (const gchar *v,
gint *major,
gint *minor,
gint *micro)
{
gchar **versions;
*major = 0;
*minor = 0;
*micro = 0;
if (v == NULL)
return FALSE;
versions = g_strsplit_set (v, ".", 3);
if (versions[0] != NULL)
{
*major = g_ascii_strtoll (versions[0], NULL, 10);
if (versions[1] != NULL)
{
*minor = g_ascii_strtoll (versions[1], NULL, 10);
if (versions[2] != NULL)
{
*micro = g_ascii_strtoll (versions[2], NULL, 10);
return TRUE;
}
}
}
g_strfreev (versions);
return (*major > 0);
}
static void
gimp_check_updates_callback (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GFileInputStream *stream;
GimpCoreConfig *config = user_data;
GError *error = NULL;
stream = g_file_read_finish (G_FILE (source), result, &error);
if (stream)
{
app: update gimp-update to new gimp_versions.json format. Instead of storing versions as objects, we now store them as arrays, because json arrays are ordered, unlike objects (the website was using non-standard Python extension to consider the version objects ordered but this is not proper and even more, the lib we use for GIMP does not have a similar extension. This simplifies a bit the code as we don't need to order the versions by comparing their string representations.
2020-01-24 05:08:33 +08:00
const gchar *build_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.
*/
if (g_strcmp0 (GIMP_BUILD_PLATFORM, "windows") == 0 ||
g_strcmp0 (GIMP_BUILD_PLATFORM, "macos") == 0)
build_platform = GIMP_BUILD_PLATFORM;
else
build_platform = "source";
app: check last GIMP release from gimp.org/gimp_versions.json. GIMP will now process the remote gimp_versions json file to look if one is using the last version of GIMP. This initial code doesn't act up yet on this information. This will come in further commits. Here are the characteristics: - Since this requires internet access, a new checkbox is available in the Preferences dialog, allowing to disable version checks. Note that it is enabled by default as it is an important security feature, but it has to be deactivatable. - The remote access is done as an async operation because we don't want it to block the startup in any way (for whatever reason). Also it doesn't output errors if it fails to not be a bother (you don't technically need internet access for an image program). - We don't check at every startup. At each successful check, we save a timestamp to prevent too frequent useless checks (I set it the timer to a week or more for now).
2019-12-09 02:08:49 +08:00
parser = json_parser_new ();
if (! json_parser_load_from_stream (parser, G_INPUT_STREAM (stream), NULL, &error))
{
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
#ifdef GIMP_UNSTABLE
g_printerr("Parsing of %s failed: %s\n",
g_file_get_uri (G_FILE (source)), error->message);
#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
g_clear_object (&stream);
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:
* g_strdup_printf ("$['STABLE'][?(@.%s)]['version']", build_platform);
* json_array_get_string_element (result, 0);
* And that would be it! We'd have our last release for given
* platform.
* Unfortunately json-glib does not support filter syntax, so we
* end up looping through releases.
*/
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
g_clear_object (&stream);
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);
if (json_object_has_member (version, build_platform))
{
last_version = json_object_get_string_member (version, "version");
release_date = json_object_get_string_member (version, "date");
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
builds = json_object_get_array_member (version, build_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: now also process the build revision when checking for updates. The idea is to be able to advertize a new revision of the same version of GIMP. For instance, this would apply when we release a `gimp-2-10-14-setup-3.exe` Windows installer (then we are at revision 3, provided we started at revision 0). The revision number is obviously only relevant to a given platform and version. Also the concept of build ID allows to differentiate various builds for a same platform, in particular to not look at revisions of third-party builds. The build ID can be any string. Maybe we could just use reverse DNS build id (such as "org.gimp.GIMP_official") to identify the official GIMP build. So in the end, we only compare revisions for an identical (version, platform, build-id) tuple.
2020-02-07 04:47:00 +08:00
const gchar *build_date = NULL;
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)
{
build_revision = json_object_get_int_member (build, "revision");
build_date = json_object_get_string_member (build, "date");
break;
}
}
if (build_revision <= GIMP_BUILD_REVISION)
{
/* Already using the last officially released
* revision. */
last_version = NULL;
}
}
str = g_strdup_printf ("%s 00:00:00Z", build_date ? build_date : release_date);
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: 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);
g_object_unref (stream);
}
}
app: show the About dialog at startup when a new version is available. This about dialog will complain an explicit message about the new version and a link button to go to the download page.
2019-12-29 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
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_file_read_async (gimp_versions, 0, NULL, gimp_check_updates_callback, config);
g_object_unref (gimp_versions);
return TRUE;
}