static VALUE
rg_initialize(VALUE self, VALUE base_stream, VALUE converter)
{
G_INITIALIZE(self,
g_converter_output_stream_new(RVAL2GOUTPUTSTREAM(base_stream),
RVAL2GCONVERTER(converter)));
return Qnil;
}
bool gunzip_file(const char *path)
{
GFile *in = NULL, *out = NULL;
autofree(gchar) *newpath = NULL;
autofree(GFileInputStream) *fis = NULL;
autofree(GFileOutputStream) *fos = NULL;
autofree(GOutputStream) *cos = NULL;
autofree(GZlibDecompressor) *conv = NULL;
gsize ret;
newpath = g_strdup(path);
if (g_str_has_suffix(newpath, ".gz")) {
newpath = str_replace(newpath, ".gz", "");
}
in = g_file_new_for_path(path);
out = g_file_new_for_path(newpath);
fis = g_file_read(in, NULL, NULL);
if (!fis) {
return NULL;
}
fos = g_file_replace(out, NULL, FALSE, 0, NULL, NULL);
if (!fos) {
return NULL;
}
conv = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_GZIP);
cos = g_converter_output_stream_new(G_OUTPUT_STREAM(fos), G_CONVERTER(conv));
if (!cos) {
return NULL;
}
ret = g_output_stream_splice(cos, G_INPUT_STREAM(fis), G_OUTPUT_STREAM_SPLICE_NONE, NULL, NULL);
return (ret > 0 ? true : false );
}
bool TextFileSaver::step()
{
GOutputStream *stream = NULL;
// Open the file.
GFile *file = g_file_new_for_uri(uri());
GFileOutputStream *fileStream = g_file_replace(file,
NULL,
TRUE,
G_FILE_CREATE_NONE,
NULL,
&m_error);
if (!fileStream)
{
g_object_unref(file);
return true;
}
// Open the encoding converter and setup the input stream.
if (m_encoding == "UTF-8")
stream = G_OUTPUT_STREAM(fileStream);
else
{
GCharsetConverter *encodingConverter =
g_charset_converter_new(m_encoding.c_str(), "UTF-8", &m_error);
if (!encodingConverter)
{
g_object_unref(file);
g_object_unref(fileStream);
return true;
}
stream =
g_converter_output_stream_new(G_OUTPUT_STREAM(fileStream),
G_CONVERTER(encodingConverter));
g_object_unref(fileStream);
g_object_unref(encodingConverter);
}
// Convert and write.
int size =
g_output_stream_write(stream,
m_text.get(),
m_length == -1 ? strlen(m_text.get()) : m_length,
NULL,
&m_error);
if (size == -1)
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
if (!g_output_stream_close(stream, NULL, &m_error))
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
g_object_unref(stream);
// Get the time when the file was last modified.
GFileInfo *fileInfo;
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.seconds = g_file_info_get_attribute_uint64(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
g_object_unref(fileInfo);
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.microSeconds = g_file_info_get_attribute_uint32(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
g_object_unref(fileInfo);
g_object_unref(file);
return true;
}
static gboolean
_gtr_po_load_ensure_utf8 (GtrPo * po, GError ** error)
{
GMappedFile *mapped;
const gchar *content;
gboolean utf8_valid;
gchar *filename;
gsize size;
GtrPoPrivate *priv = gtr_po_get_instance_private (po);
filename = g_file_get_path (priv->location);
mapped = g_mapped_file_new (filename, FALSE, error);
g_free (filename);
if (!mapped)
return FALSE;
content = g_mapped_file_get_contents (mapped);
size = g_mapped_file_get_length (mapped);
utf8_valid = g_utf8_validate (content, size, NULL);
if (!_gtr_po_load (po, priv->location, error))
{
g_mapped_file_unref (mapped);
return FALSE;
}
if (!utf8_valid &&
priv->header)
{
gchar *charset = NULL;
if (priv->header)
charset = gtr_header_get_charset (priv->header);
if (charset && *charset && strcmp (charset, "UTF-8") != 0)
{
GOutputStream *converter_stream, *stream;
GCharsetConverter *converter;
GIOStream *iostream;
GFile *tmp;
/* Store UTF-8 converted file in $TMP */
converter = g_charset_converter_new ("UTF-8", charset, NULL);
if (!converter)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not convert from charset “%s” to UTF-8"),
charset);
g_mapped_file_unref (mapped);
g_free (charset);
return FALSE;
}
g_free (charset);
tmp = g_file_new_tmp ("gtranslator-XXXXXX.po",
(GFileIOStream **) &iostream,
NULL);
if (!tmp)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not store temporary "
"file for encoding conversion"));
g_mapped_file_unref (mapped);
g_object_unref (converter);
return FALSE;
}
stream = g_io_stream_get_output_stream (iostream);
converter_stream =
g_converter_output_stream_new (stream,
G_CONVERTER (converter));
if (!g_output_stream_write_all (converter_stream,
content, size, NULL,
NULL, NULL))
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not store temporary "
"file for encoding conversion"));
g_object_unref (converter_stream);
g_object_unref (iostream);
g_object_unref (converter);
g_mapped_file_unref (mapped);
return FALSE;
}
g_object_unref (converter_stream);
g_object_unref (iostream);
g_object_unref (converter);
/* Now load again the converted file */
if (!_gtr_po_load (po, tmp, error))
{
g_mapped_file_unref (mapped);
return FALSE;
}
/* Ensure Content-Type is set correctly
* in the header as per the content
*/
if (priv->header)
gtr_header_set_charset (priv->header, "UTF-8");
utf8_valid = TRUE;
}
}
g_mapped_file_unref (mapped);
if (!utf8_valid)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("All attempt to convert the file to UTF-8 has failed, "
"use the msgconv or iconv command line tools before "
"opening this file with GNOME Translation Editor"));
return FALSE;
}
return TRUE;
}
static void
end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ParseState *state = user_data;
GError *my_error = NULL;
if (strcmp (element_name, "gresource") == 0)
{
g_free (state->prefix);
state->prefix = NULL;
}
else if (strcmp (element_name, "file") == 0)
{
gchar *file;
gchar *real_file = NULL;
gchar *key;
FileData *data = NULL;
char *tmp_file = NULL;
char *tmp_file2 = NULL;
file = state->string->str;
key = file;
if (state->alias)
key = state->alias;
if (state->prefix)
key = g_build_path ("/", "/", state->prefix, key, NULL);
else
key = g_build_path ("/", "/", key, NULL);
if (g_hash_table_lookup (state->table, key) != NULL)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("File %s appears multiple times in the resource"),
key);
return;
}
if (sourcedirs != NULL)
{
real_file = find_file (file);
if (real_file == NULL && state->collect_data)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Failed to locate “%s” in any source directory"), file);
return;
}
}
else
{
gboolean exists;
exists = g_file_test (file, G_FILE_TEST_EXISTS);
if (!exists && state->collect_data)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Failed to locate “%s” in current directory"), file);
return;
}
}
if (real_file == NULL)
real_file = g_strdup (file);
data = g_new0 (FileData, 1);
data->filename = g_strdup (real_file);
if (!state->collect_data)
goto done;
if (state->preproc_options)
{
gchar **options;
guint i;
gboolean xml_stripblanks = FALSE;
gboolean to_pixdata = FALSE;
options = g_strsplit (state->preproc_options, ",", -1);
for (i = 0; options[i]; i++)
{
if (!strcmp (options[i], "xml-stripblanks"))
xml_stripblanks = TRUE;
else if (!strcmp (options[i], "to-pixdata"))
to_pixdata = TRUE;
else
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Unknown processing option “%s”"), options[i]);
g_strfreev (options);
goto cleanup;
}
}
g_strfreev (options);
if (xml_stripblanks && xmllint != NULL)
{
int fd;
GSubprocess *proc;
tmp_file = g_strdup ("resource-XXXXXXXX");
if ((fd = g_mkstemp (tmp_file)) == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
_("Failed to create temp file: %s"),
g_strerror (errsv));
g_free (tmp_file);
tmp_file = NULL;
goto cleanup;
}
close (fd);
proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
xmllint, "--nonet", "--noblanks", "--output", tmp_file, real_file, NULL);
g_free (real_file);
real_file = NULL;
if (!proc)
goto cleanup;
if (!g_subprocess_wait_check (proc, NULL, error))
{
g_object_unref (proc);
goto cleanup;
}
g_object_unref (proc);
real_file = g_strdup (tmp_file);
}
if (to_pixdata)
{
int fd;
GSubprocess *proc;
if (gdk_pixbuf_pixdata == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"to-pixbuf preprocessing requested but GDK_PIXBUF_PIXDATA "
"not set and gdk-pixbuf-pixdata not found in path");
goto cleanup;
}
tmp_file2 = g_strdup ("resource-XXXXXXXX");
if ((fd = g_mkstemp (tmp_file2)) == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
_("Failed to create temp file: %s"),
g_strerror (errsv));
g_free (tmp_file2);
tmp_file2 = NULL;
goto cleanup;
}
close (fd);
proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
gdk_pixbuf_pixdata, real_file, tmp_file2, NULL);
g_free (real_file);
real_file = NULL;
if (!g_subprocess_wait_check (proc, NULL, error))
{
g_object_unref (proc);
goto cleanup;
}
g_object_unref (proc);
real_file = g_strdup (tmp_file2);
}
}
if (!g_file_get_contents (real_file, &data->content, &data->size, &my_error))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Error reading file %s: %s"),
real_file, my_error->message);
g_clear_error (&my_error);
goto cleanup;
}
/* Include zero termination in content_size for uncompressed files (but not in size) */
data->content_size = data->size + 1;
if (state->compressed)
{
GOutputStream *out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
GZlibCompressor *compressor =
g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9);
GOutputStream *out2 = g_converter_output_stream_new (out, G_CONVERTER (compressor));
if (!g_output_stream_write_all (out2, data->content, data->size,
NULL, NULL, NULL) ||
!g_output_stream_close (out2, NULL, NULL))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Error compressing file %s"),
real_file);
goto cleanup;
}
g_free (data->content);
data->content_size = g_memory_output_stream_get_size (G_MEMORY_OUTPUT_STREAM (out));
data->content = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
g_object_unref (compressor);
g_object_unref (out);
g_object_unref (out2);
data->flags |= G_RESOURCE_FLAGS_COMPRESSED;
}
done:
g_hash_table_insert (state->table, key, data);
data = NULL;
cleanup:
/* Cleanup */
g_free (state->alias);
state->alias = NULL;
g_string_free (state->string, TRUE);
state->string = NULL;
g_free (state->preproc_options);
state->preproc_options = NULL;
g_free (real_file);
if (tmp_file)
{
unlink (tmp_file);
g_free (tmp_file);
}
if (tmp_file2)
{
unlink (tmp_file2);
g_free (tmp_file2);
}
if (data != NULL)
file_data_free (data);
}
}
static void
end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ParseState *state = user_data;
GError *my_error = NULL;
if (strcmp (element_name, "gresource") == 0)
{
g_free (state->prefix);
state->prefix = NULL;
}
else if (strcmp (element_name, "file") == 0)
{
gchar *file, *real_file;
gchar *key;
FileData *data;
char *tmp_file = NULL;
char *tmp_file2 = NULL;
file = state->string->str;
key = file;
if (state->alias)
key = state->alias;
if (state->prefix)
key = g_build_path ("/", "/", state->prefix, key, NULL);
else
key = g_build_path ("/", "/", key, NULL);
if (g_hash_table_lookup (state->table, key) != NULL)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("File %s appears multiple times in the resource"),
key);
return;
}
data = g_new0 (FileData, 1);
if (sourcedirs != NULL)
{
real_file = find_file (file);
if (real_file == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Failed to locate '%s' in any source directory"), file);
return;
}
}
else
{
gboolean exists;
exists = g_file_test (file, G_FILE_TEST_EXISTS);
if (!exists)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Failed to locate '%s' in current directory"), file);
return;
}
real_file = g_strdup (file);
}
data->filename = g_strdup (real_file);
if (!state->collect_data)
goto done;
if (state->preproc_options)
{
gchar **options;
guint i;
gboolean xml_stripblanks = FALSE;
gboolean to_pixdata = FALSE;
options = g_strsplit (state->preproc_options, ",", -1);
for (i = 0; options[i]; i++)
{
if (!strcmp (options[i], "xml-stripblanks"))
xml_stripblanks = TRUE;
else if (!strcmp (options[i], "to-pixdata"))
to_pixdata = TRUE;
else
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Unknown processing option \"%s\""), options[i]);
g_strfreev (options);
goto cleanup;
}
}
g_strfreev (options);
if (xml_stripblanks && xmllint != NULL)
{
gchar *argv[8];
int status, fd, argc;
tmp_file = g_strdup ("resource-XXXXXXXX");
if ((fd = g_mkstemp (tmp_file)) == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
_("Failed to create temp file: %s"),
g_strerror (errsv));
g_free (tmp_file);
tmp_file = NULL;
goto cleanup;
}
close (fd);
argc = 0;
argv[argc++] = (gchar *) xmllint;
argv[argc++] = "--nonet";
argv[argc++] = "--noblanks";
argv[argc++] = "--output";
argv[argc++] = tmp_file;
argv[argc++] = real_file;
argv[argc++] = NULL;
g_assert (argc <= G_N_ELEMENTS (argv));
if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */,
G_SPAWN_STDOUT_TO_DEV_NULL |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, NULL, NULL, NULL, &status, &my_error))
{
g_propagate_error (error, my_error);
goto cleanup;
}
#ifdef HAVE_SYS_WAIT_H
if (!WIFEXITED (status) || WEXITSTATUS (status) != 0)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Error processing input file with xmllint"));
goto cleanup;
}
#endif
g_free (real_file);
real_file = g_strdup (tmp_file);
}
if (to_pixdata)
{
gchar *argv[4];
int status, fd, argc;
if (gdk_pixbuf_pixdata == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"to-pixbuf preprocessing requested but GDK_PIXBUF_PIXDATA "
"not set and gdk-pixbuf-pixdata not found in path");
goto cleanup;
}
tmp_file2 = g_strdup ("resource-XXXXXXXX");
if ((fd = g_mkstemp (tmp_file2)) == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
_("Failed to create temp file: %s"),
g_strerror (errsv));
g_free (tmp_file2);
tmp_file2 = NULL;
goto cleanup;
}
close (fd);
argc = 0;
argv[argc++] = (gchar *) gdk_pixbuf_pixdata;
argv[argc++] = real_file;
argv[argc++] = tmp_file2;
argv[argc++] = NULL;
g_assert (argc <= G_N_ELEMENTS (argv));
if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */,
G_SPAWN_STDOUT_TO_DEV_NULL |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, NULL, NULL, NULL, &status, &my_error))
{
g_propagate_error (error, my_error);
goto cleanup;
}
#ifdef HAVE_SYS_WAIT_H
if (!WIFEXITED (status) || WEXITSTATUS (status) != 0)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Error processing input file with to-pixdata"));
goto cleanup;
}
#endif
g_free (real_file);
real_file = g_strdup (tmp_file2);
}
}
if (!g_file_get_contents (real_file, &data->content, &data->size, &my_error))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Error reading file %s: %s"),
real_file, my_error->message);
g_clear_error (&my_error);
goto cleanup;
}
/* Include zero termination in content_size for uncompressed files (but not in size) */
data->content_size = data->size + 1;
if (state->compressed)
{
GOutputStream *out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
GZlibCompressor *compressor =
g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9);
GOutputStream *out2 = g_converter_output_stream_new (out, G_CONVERTER (compressor));
if (!g_output_stream_write_all (out2, data->content, data->size,
NULL, NULL, NULL) ||
!g_output_stream_close (out2, NULL, NULL))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Error compressing file %s"),
real_file);
goto cleanup;
}
g_free (data->content);
data->content_size = g_memory_output_stream_get_size (G_MEMORY_OUTPUT_STREAM (out));
data->content = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
g_object_unref (compressor);
g_object_unref (out);
g_object_unref (out2);
data->flags |= G_RESOURCE_FLAGS_COMPRESSED;
}
done:
g_hash_table_insert (state->table, key, data);
cleanup:
/* Cleanup */
g_free (state->alias);
state->alias = NULL;
g_string_free (state->string, TRUE);
state->string = NULL;
g_free (state->preproc_options);
state->preproc_options = NULL;
g_free (real_file);
if (tmp_file)
{
unlink (tmp_file);
g_free (tmp_file);
}
if (tmp_file2)
{
unlink (tmp_file2);
g_free (tmp_file2);
}
}
}
int
main (int argc, char *argv[])
{
FlatpakInstallation *installation;
FlatpakInstalledRef *app1;
FlatpakInstalledRef *app2;
FlatpakRemoteRef *remote_ref;
g_autoptr(GPtrArray) remotes = NULL;
GError *error = NULL;
int i, j, k;
installation = flatpak_installation_new_user (NULL, &error);
if (installation == NULL)
{
g_print ("error: %s\n", error->message);
return 1;
}
if (0)
{
const char *list[] = { "gnome-apps", "app/org.gnome.iagno/x86_64/stable",
"gnome", "runtime/org.gnome.Sdk/x86_64/3.20" };
for (j = 0; j < G_N_ELEMENTS (list); j += 2)
{
g_print ("looking for related to ref: %s\n", list[j + 1]);
for (k = 0; k < 2; k++)
{
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) related = NULL;
if (k == 0)
related = flatpak_installation_list_remote_related_refs_sync (installation,
list[j],
list[j + 1],
NULL,
&error);
else
related = flatpak_installation_list_installed_related_refs_sync (installation,
list[j],
list[j + 1],
NULL,
&error);
if (related == NULL)
{
g_warning ("Error: %s", error->message);
continue;
}
g_print ("%s related:\n", (k == 0) ? "remote" : "local");
for (i = 0; i < related->len; i++)
{
FlatpakRelatedRef *rel = g_ptr_array_index (related, i);
const char * const *subpaths = flatpak_related_ref_get_subpaths (rel);
g_autofree char *subpaths_str = NULL;
if (subpaths)
{
g_autofree char *subpaths_joined = g_strjoinv (",", (char **) subpaths);
subpaths_str = g_strdup_printf (" subpaths: %s", subpaths_joined);
}
else
subpaths_str = g_strdup ("");
g_print ("%d %s %s %s %s dl:%d del:%d%s\n",
flatpak_ref_get_kind (FLATPAK_REF (rel)),
flatpak_ref_get_name (FLATPAK_REF (rel)),
flatpak_ref_get_arch (FLATPAK_REF (rel)),
flatpak_ref_get_branch (FLATPAK_REF (rel)),
flatpak_ref_get_commit (FLATPAK_REF (rel)),
flatpak_related_ref_should_download (rel),
flatpak_related_ref_should_delete (rel),
subpaths_str);
}
}
}
return 0;
}
if (argc == 4)
{
GFileMonitor * monitor = flatpak_installation_create_monitor (installation, NULL, NULL);
GMainLoop *main_loop;
g_signal_connect (monitor, "changed", (GCallback) monitor_callback, NULL);
main_loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (main_loop);
}
if (argc == 3)
{
app1 = flatpak_installation_install (installation,
argv[1],
FLATPAK_REF_KIND_APP,
argv[2],
NULL, NULL,
progress_cb, (gpointer) 0xdeadbeef,
NULL, &error);
if (app1 == NULL)
g_print ("Error: %s\n", error->message);
else
g_print ("Installed %s: %s\n", argv[2],
flatpak_ref_get_commit (FLATPAK_REF (app1)));
return 0;
}
if (argc == 2)
{
app1 = flatpak_installation_update (installation,
FLATPAK_UPDATE_FLAGS_NONE,
FLATPAK_REF_KIND_APP,
argv[1],
NULL, NULL,
progress_cb, (gpointer) 0xdeadbeef,
NULL, &error);
if (app1 == NULL)
g_print ("Error: %s\n", error->message);
else
g_print ("Updated %s: %s\n", argv[1],
flatpak_ref_get_commit (FLATPAK_REF (app1)));
return 0;
}
g_print ("\n**** Loading bundle\n");
{
g_autoptr(GFile) f = g_file_new_for_commandline_arg ("tests/hello.pak");
g_autoptr(FlatpakBundleRef) bundle = flatpak_bundle_ref_new (f, &error);
if (bundle == NULL)
{
g_print ("Error loading bundle: %s\n", error->message);
g_clear_error (&error);
}
else
{
g_autofree char *path = g_file_get_path (flatpak_bundle_ref_get_file (bundle));
g_autoptr(GBytes) metadata = flatpak_bundle_ref_get_metadata (bundle);
g_autoptr(GBytes) appdata = flatpak_bundle_ref_get_appstream (bundle);
g_print ("%d %s %s %s %s %s %"G_GUINT64_FORMAT "\n%s\n",
flatpak_ref_get_kind (FLATPAK_REF (bundle)),
flatpak_ref_get_name (FLATPAK_REF (bundle)),
flatpak_ref_get_arch (FLATPAK_REF (bundle)),
flatpak_ref_get_branch (FLATPAK_REF (bundle)),
flatpak_ref_get_commit (FLATPAK_REF (bundle)),
path,
flatpak_bundle_ref_get_installed_size (bundle),
(char *) g_bytes_get_data (metadata, NULL));
if (appdata != NULL)
{
g_autoptr(GZlibDecompressor) decompressor = NULL;
g_autoptr(GOutputStream) out2 = NULL;
g_autoptr(GOutputStream) out = NULL;
out = g_unix_output_stream_new (1, FALSE);
decompressor = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP);
out2 = g_converter_output_stream_new (out, G_CONVERTER (decompressor));
if (!g_output_stream_write_all (out2,
g_bytes_get_data (appdata, NULL),
g_bytes_get_size (appdata),
NULL, NULL, &error))
{
g_print ("Error decompressing appdata: %s\n", error->message);
g_clear_error (&error);
}
}
}
}
g_print ("\n**** Checking for updates\n");
{
g_autoptr(GPtrArray) updates =
flatpak_installation_list_installed_refs_for_update (installation,
NULL, &error);
if (updates == NULL)
{
g_print ("check for updates error: %s\n", error->message);
g_clear_error (&error);
}
else
{
for (i = 0; i < updates->len; i++)
{
FlatpakInstalledRef *ref = g_ptr_array_index (updates, i);
g_print ("%d %s %s %s %s %s %s %s %d %"G_GUINT64_FORMAT "\n",
flatpak_ref_get_kind (FLATPAK_REF (ref)),
flatpak_ref_get_name (FLATPAK_REF (ref)),
flatpak_ref_get_arch (FLATPAK_REF (ref)),
flatpak_ref_get_branch (FLATPAK_REF (ref)),
flatpak_ref_get_commit (FLATPAK_REF (ref)),
flatpak_installed_ref_get_latest_commit (ref),
flatpak_installed_ref_get_origin (ref),
flatpak_installed_ref_get_deploy_dir (ref),
flatpak_installed_ref_get_is_current (ref),
flatpak_installed_ref_get_installed_size (ref));
}
}
}
g_print ("\n**** Listing all installed refs\n");
{
g_autoptr(GPtrArray) refs = NULL;
refs = flatpak_installation_list_installed_refs (installation,
NULL, NULL);
for (i = 0; i < refs->len; i++)
{
FlatpakInstalledRef *ref = g_ptr_array_index (refs, i);
g_print ("%d %s %s %s %s %s %s %s %d %"G_GUINT64_FORMAT "\n",
flatpak_ref_get_kind (FLATPAK_REF (ref)),
flatpak_ref_get_name (FLATPAK_REF (ref)),
flatpak_ref_get_arch (FLATPAK_REF (ref)),
flatpak_ref_get_branch (FLATPAK_REF (ref)),
flatpak_ref_get_commit (FLATPAK_REF (ref)),
flatpak_installed_ref_get_latest_commit (ref),
flatpak_installed_ref_get_origin (ref),
flatpak_installed_ref_get_deploy_dir (ref),
flatpak_installed_ref_get_is_current (ref),
flatpak_installed_ref_get_installed_size (ref));
}
}
g_print ("**** Listing all installed apps\n");
{
g_autoptr(GPtrArray) apps = NULL;
apps = flatpak_installation_list_installed_refs_by_kind (installation,
FLATPAK_REF_KIND_APP,
NULL, NULL);
for (i = 0; i < apps->len; i++)
{
FlatpakInstalledRef *app = g_ptr_array_index (apps, i);
g_print ("%d %s %s %s %s %s %s %s %d %"G_GUINT64_FORMAT "\n",
flatpak_ref_get_kind (FLATPAK_REF (app)),
flatpak_ref_get_name (FLATPAK_REF (app)),
flatpak_ref_get_arch (FLATPAK_REF (app)),
flatpak_ref_get_branch (FLATPAK_REF (app)),
flatpak_ref_get_commit (FLATPAK_REF (app)),
flatpak_installed_ref_get_latest_commit (app),
flatpak_installed_ref_get_origin (app),
flatpak_installed_ref_get_deploy_dir (app),
flatpak_installed_ref_get_is_current (app),
flatpak_installed_ref_get_installed_size (app));
g_print ("metadata:\n%s\n", (char *) g_bytes_get_data (flatpak_installed_ref_load_metadata (app, NULL, NULL), NULL));
}
}
g_print ("\n**** Listing all installed runtimes\n");
{
g_autoptr(GPtrArray) runtimes = NULL;
runtimes = flatpak_installation_list_installed_refs_by_kind (installation,
FLATPAK_REF_KIND_RUNTIME,
NULL, NULL);
for (i = 0; i < runtimes->len; i++)
{
FlatpakInstalledRef *runtime = g_ptr_array_index (runtimes, i);
g_print ("%d %s %s %s %s %s %s %d\n",
flatpak_ref_get_kind (FLATPAK_REF (runtime)),
flatpak_ref_get_name (FLATPAK_REF (runtime)),
flatpak_ref_get_arch (FLATPAK_REF (runtime)),
flatpak_ref_get_branch (FLATPAK_REF (runtime)),
flatpak_ref_get_commit (FLATPAK_REF (runtime)),
flatpak_installed_ref_get_origin (runtime),
flatpak_installed_ref_get_deploy_dir (runtime),
flatpak_installed_ref_get_is_current (runtime));
}
}
g_print ("\n**** Getting installed gedit master\n");
app1 = flatpak_installation_get_installed_ref (installation,
FLATPAK_REF_KIND_APP,
"org.gnome.gedit",
NULL, "master", NULL, NULL);
if (app1)
{
g_print ("gedit master: %d %s %s %s %s %s %s %d\n",
flatpak_ref_get_kind (FLATPAK_REF (app1)),
flatpak_ref_get_name (FLATPAK_REF (app1)),
flatpak_ref_get_arch (FLATPAK_REF (app1)),
flatpak_ref_get_branch (FLATPAK_REF (app1)),
flatpak_ref_get_commit (FLATPAK_REF (app1)),
flatpak_installed_ref_get_origin (app1),
flatpak_installed_ref_get_deploy_dir (app1),
flatpak_installed_ref_get_is_current (app1));
}
if (!flatpak_installation_launch (installation,
"org.gnome.gedit",
NULL, NULL, NULL,
NULL, &error))
{
g_print ("launch gedit error: %s\n", error->message);
g_clear_error (&error);
}
g_print ("\n**** Getting current installed gedit\n");
app2 = flatpak_installation_get_current_installed_app (installation,
"org.gnome.gedit",
NULL, NULL);
if (app2)
{
g_print ("gedit current: %d %s %s %s %s %s %s %d\n",
flatpak_ref_get_kind (FLATPAK_REF (app2)),
flatpak_ref_get_name (FLATPAK_REF (app2)),
flatpak_ref_get_arch (FLATPAK_REF (app2)),
flatpak_ref_get_branch (FLATPAK_REF (app2)),
flatpak_ref_get_commit (FLATPAK_REF (app2)),
flatpak_installed_ref_get_origin (app2),
flatpak_installed_ref_get_deploy_dir (app2),
flatpak_installed_ref_get_is_current (app2));
}
g_print ("\n**** Listing remotes\n");
remotes = flatpak_installation_list_remotes (installation,
NULL, NULL);
for (i = 0; i < remotes->len; i++)
{
FlatpakRemote *remote = g_ptr_array_index (remotes, i);
g_autoptr(GPtrArray) refs = NULL;
const char *collection_id = NULL;
collection_id = flatpak_remote_get_collection_id (remote);
g_print ("\nRemote: %s %u %d %s %s %s %s %d %d %s\n",
flatpak_remote_get_name (remote),
flatpak_remote_get_remote_type (remote),
flatpak_remote_get_prio (remote),
flatpak_remote_get_url (remote),
collection_id,
flatpak_remote_get_title (remote),
flatpak_remote_get_default_branch (remote),
flatpak_remote_get_gpg_verify (remote),
flatpak_remote_get_noenumerate (remote),
g_file_get_path (flatpak_remote_get_appstream_dir (remote, NULL)));
g_print ("\n**** Listing remote refs on %s\n", flatpak_remote_get_name (remote));
refs = flatpak_installation_list_remote_refs_sync (installation, flatpak_remote_get_name (remote),
NULL, NULL);
if (refs)
{
for (j = 0; j < refs->len; j++)
{
FlatpakRemoteRef *ref = g_ptr_array_index (refs, j);
g_print ("%d %s %s %s %s %s\n",
flatpak_ref_get_kind (FLATPAK_REF (ref)),
flatpak_ref_get_name (FLATPAK_REF (ref)),
flatpak_ref_get_arch (FLATPAK_REF (ref)),
flatpak_ref_get_branch (FLATPAK_REF (ref)),
flatpak_ref_get_commit (FLATPAK_REF (ref)),
flatpak_remote_ref_get_remote_name (ref));
if (j == 0)
{
guint64 download_size;
guint64 installed_size;
if (!flatpak_installation_fetch_remote_size_sync (installation,
flatpak_remote_get_name (remote),
FLATPAK_REF (ref),
&download_size,
&installed_size,
NULL, &error))
{
g_print ("error fetching sizes: %s\n", error->message);
g_clear_error (&error);
}
else
{
g_print ("Download size: %"G_GUINT64_FORMAT " Installed size: %"G_GUINT64_FORMAT "\n",
download_size, installed_size);
}
}
}
}
g_print ("\n**** Getting remote platform 3.20 on %s\n", flatpak_remote_get_name (remote));
error = NULL;
remote_ref = flatpak_installation_fetch_remote_ref_sync (installation, flatpak_remote_get_name (remote),
FLATPAK_REF_KIND_RUNTIME,
"org.gnome.Platform", NULL, "3.20",
NULL, &error);
if (remote_ref)
{
GBytes *metadata;
g_print ("%d %s %s %s %s %s\n",
flatpak_ref_get_kind (FLATPAK_REF (remote_ref)),
flatpak_ref_get_name (FLATPAK_REF (remote_ref)),
flatpak_ref_get_arch (FLATPAK_REF (remote_ref)),
flatpak_ref_get_branch (FLATPAK_REF (remote_ref)),
flatpak_ref_get_commit (FLATPAK_REF (remote_ref)),
flatpak_remote_ref_get_remote_name (remote_ref));
metadata = flatpak_installation_fetch_remote_metadata_sync (installation, flatpak_remote_get_name (remote),
FLATPAK_REF (remote_ref), NULL, &error);
if (metadata)
{
g_print ("metadata: %s\n", (char *) g_bytes_get_data (metadata, NULL));
}
else
{
g_print ("fetch error\n");
g_print ("error: %s\n", error->message);
g_clear_error (&error);
}
}
else
{
g_print ("error: %s\n", error->message);
g_clear_error (&error);
}
}
return 0;
}
