p96705831
/
gimp
forked from openkylin/gimp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
gimp/app/gimp-update.c

480 lines
16 KiB
C
Raw Permalink Blame History

/* 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>
#ifndef GIMP_CONSOLE_COMPILATION
#include <gtk/gtk.h>
#endif
#include "libgimpbase/gimpbase.h"
#include "core/core-types.h"
#include "config/gimpcoreconfig.h"
#ifndef GIMP_CONSOLE_COMPILATION
#include "dialogs/about-dialog.h"
#endif
#include "gimp-intl.h"
#include "gimp-update.h"
#include "gimp-version.h"
static gboolean gimp_update_known (GimpCoreConfig *config,
const gchar *last_version,
gint64 release_timestamp,
gint build_revision,
const gchar *comment);
static gboolean gimp_version_break (const gchar *v,
gint *major,
gint *minor,
gint *micro);
static void gimp_check_updates_callback (GObject *source,
GAsyncResult *result,
gpointer user_data);
static void gimp_update_about_dialog (GimpCoreConfig *config,
const GParamSpec *pspec,
gpointer user_data);
/* Private Functions */
/**
* gimp_update_known:
* @config:
* @last_version:
* @release_timestamp: must be non-zero is @last_version is not %NULL.
* @build_revision:
* @build_comment:
*
* Compare @last_version with currently running version. If the checked
* version is more recent than running version, then @config properties
* are updated appropriately (which may trigger a dialog depending on
* update policy settings).
* If @last_version is %NULL, the currently stored "last known release"
* is compared. Even if we haven't made any new remote checks, it is
* important to always compare again stored last release, otherwise we
* might warn of the same current version, or worse an older version.
*
* Returns: %TRUE is @last_version (or stored last known release if
* @last_version was %NULL) is newer than running version.
*/
static gboolean
gimp_update_known (GimpCoreConfig *config,
const gchar *last_version,
gint64 release_timestamp,
gint build_revision,
const gchar *build_comment)
{
gboolean new_check = (last_version != NULL);
gint major;
gint minor;
gint micro;
if (last_version && release_timestamp == 0)
{
/* I don't exit with a g_return_val_if_fail() assert because this
* is not necessarily a code bug. It may be data issues. So let's
* just return with an error printed on stderr.
*/
g_printerr ("%s: version %s with no release dates.\n",
G_STRFUNC, last_version);
return FALSE;
}
if (last_version == NULL)
{
last_version = config->last_known_release;
release_timestamp = config->last_release_timestamp;
build_revision = config->last_revision;
build_comment = config->last_release_comment;
}
if (last_version)
{
if (gimp_version_break (last_version, &major, &minor, &micro))
{
if (/* We are using a newer version than last check. This could
* happen if updating the config files without having
* re-checked the remote JSON file.
*/
(major < GIMP_MAJOR_VERSION ||
(major == GIMP_MAJOR_VERSION && minor < GIMP_MINOR_VERSION) ||
(major == GIMP_MAJOR_VERSION && minor == GIMP_MINOR_VERSION && micro < GIMP_MICRO_VERSION)) ||
/* Already using the last officially released
* revision. */
(major == GIMP_MAJOR_VERSION &&
minor == GIMP_MINOR_VERSION &&
micro == GIMP_MICRO_VERSION &&
build_revision <= gimp_version_get_revision ()))
{
last_version = NULL;
}
}
else
{
/* If version is not properly parsed, something is wrong with
* upstream version number or parsing. This should not happen.
*/
g_printerr ("%s: version not properly formatted: %s\n",
G_STRFUNC, last_version);
return FALSE;
}
}
if (last_version == NULL)
{
release_timestamp = 0;
build_revision = 0;
build_comment = NULL;
}
if (new_check)
g_object_set (config,
"check-update-timestamp", g_get_real_time() / G_USEC_PER_SEC,
NULL);
g_object_set (config,
"last-release-timestamp", release_timestamp,
"last-known-release", last_version,
"last-revision", build_revision,
"last-release-comment", build_comment,
NULL);
/* Are we running an old GIMP? */
return (last_version != NULL);
}
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)
{
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))
{
const gchar *platform;
const gchar *last_version = NULL;
const gchar *release_date = NULL;
const gchar *build_comment = NULL;
gint64 release_timestamp = 0;
gint build_revision = 0;
JsonParser *parser;
JsonPath *path;
JsonNode *result;
JsonArray *versions;
gint i;
/* For Windows and macOS, let's look if installers are available.
* For other platforms, let's just look for source release.
*/
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";
parser = json_parser_new ();
if (! json_parser_load_from_data (parser, file_contents, file_length, &error))
{
g_printerr ("%s: parsing of %s failed: %s\n", G_STRFUNC,
g_file_get_uri (G_FILE (source)), error->message);
g_free (file_contents);
g_clear_object (&parser);
g_clear_error (&error);
return;
}
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, "$['STABLE'][*]", &error))
{
#ifdef GIMP_UNSTABLE
g_printerr("Path compilation failed: %s\n", error->message);
#endif
g_free (file_contents);
g_clear_object (&parser);
g_clear_error (&error);
return;
}
result = json_path_match (path, json_parser_get_root (parser));
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;
/* 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))
{
JsonArray *builds;
gint j;
builds = json_object_get_array_member (version, platform);
for (j = 0; j < (gint) json_array_get_length (builds); j++)
{
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)
{
/* 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 = json_object_get_string_member (build, "comment");
break;
}
}
if (release_date)
{
last_version = json_object_get_string_member (version, "version");
break;
}
}
}
if (last_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, last_version, release_date);
last_version = NULL;
release_date = NULL;
build_revision = 0;
build_comment = NULL;
}
}
gimp_update_known (config, last_version, release_timestamp, build_revision, build_comment);
g_object_unref (path);
g_object_unref (parser);
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);
}
}
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
}
}
/* Public Functions */
/*
* gimp_update_auto_check:
* @config:
*
* Run the check for newer versions of GIMP if conditions are right.
*
* Returns: %TRUE if a check was actually run.
*/
gboolean
gimp_update_auto_check (GimpCoreConfig *config)
{
gint64 prev_update_timestamp;
gint64 current_timestamp;
/* Builds with update check deactivated just always return FALSE. */
#ifdef CHECK_UPDATE
/* Allows to disable updates at package level with a build having the
* version check code built-in.
* For instance, it would allow to use the same Windows installer for
* the Windows Store (with update check disabled because it comes with
* its own update channel).
*/
if (! gimp_version_check_update () ||
! config->check_updates)
#endif
return FALSE;
g_object_get (config,
"check-update-timestamp", &prev_update_timestamp,
NULL);
current_timestamp = g_get_real_time() / G_USEC_PER_SEC;
/* Get rid of invalid saved timestamps. */
if (prev_update_timestamp > current_timestamp)
prev_update_timestamp = -1;
#ifndef GIMP_UNSTABLE
/* Do not check more than once a week. */
if (current_timestamp - prev_update_timestamp < 3600L * 24L * 7L)
return FALSE;
#endif
g_signal_connect (config, "notify::last-known-release",
(GCallback) gimp_update_about_dialog,
NULL);
gimp_update_check (config);
return TRUE;
}
/*
* gimp_update_check:
* @config:
*
* Run the check for newer versions of GIMP inconditionnally.
*/
void
gimp_update_check (GimpCoreConfig *config)
{
GFile *gimp_versions;
#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://www.gimp.org/gimp_versions.json");
#endif
g_file_load_contents_async (gimp_versions, NULL, gimp_check_updates_callback, config);
g_object_unref (gimp_versions);
}
/*
* 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);
}
Reference in New Issue View Git Blame Copy Permalink