summaryrefslogtreecommitdiff
path: root/src/autosave-manager.vala
diff options
context:
space:
mode:
authorAlessio Treglia <alessio@debian.org>2013-10-05 15:29:30 +0100
committerAlessio Treglia <alessio@debian.org>2013-10-05 15:29:30 +0100
commite51f2bbb5a0f25b37330891d769b996a2c13d277 (patch)
tree25d429c588012a476c15b6ca5b4bf393613beca3 /src/autosave-manager.vala
parent438230655b539ad6aa15b017a792cab8ca7f6d89 (diff)
parent2d71d20a62ca8f6989d86db58ce64c7a862675dd (diff)
Merge tag 'upstream/3.10.0'
Upstream version 3.10.0
Diffstat (limited to 'src/autosave-manager.vala')
-rw-r--r--src/autosave-manager.vala553
1 files changed, 553 insertions, 0 deletions
diff --git a/src/autosave-manager.vala b/src/autosave-manager.vala
new file mode 100644
index 0000000..eb8f1c5
--- /dev/null
+++ b/src/autosave-manager.vala
@@ -0,0 +1,553 @@
+/*
+ * Copyright (C) 2011 Timo Kluck
+ * Author: Timo Kluck <tkluck@infty.nl>
+ *
+ * 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. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+/*
+ * We store autosaves in a database named
+ * ~/.cache/simple-scan/autosaves/autosaves.db
+ * It contains a single table of pages, each containing the process id (pid) of
+ * the simple-scan instance that saved it, and a hash of the Book and Page
+ * objects corresponding to it. The pixels are saved as a BLOB.
+ * Additionally, the autosaves directory contains a number of tiff files that
+ * the user can use for manual recovery.
+ *
+ * At startup, we check whether autosaves.db contains any records
+ * with a pid that does not match a current pid for simple-scan. If so, we take
+ * ownership by an UPDATE statement changing to our own pid. Then, we
+ * recover the book. We're trying our best to avoid the possible race
+ * condition if several instances of simple-scan are started simultaneously.
+ *
+ * At application exit, we delete the records corresponding to our own pid.
+ *
+ * Important notes:
+ * - We enforce that there is only one AutosaveManager instance in a given
+ * process by using a create function.
+ * - It should be possible to change the book object at runtime, although this
+ * is not used in the current implementation so it has not been tested.
+ */
+
+public class AutosaveManager
+{
+ private static string AUTOSAVE_DIR = Path.build_filename (Environment.get_user_cache_dir (), "simple-scan", "autosaves");
+ private static string AUTOSAVE_NAME = "autosaves";
+ private static string AUTOSAVE_EXT = ".db";
+ private static string AUTOSAVE_FILENAME = Path.build_filename (AUTOSAVE_DIR, AUTOSAVE_NAME + AUTOSAVE_EXT);
+
+ private static string PID = ((int)(Posix.getpid ())).to_string ();
+ private static int number_of_instances = 0;
+
+ private Sqlite.Database database_connection;
+ private Book _book = null;
+
+ private uint update_timeout = 0;
+ private HashTable<Page, bool> dirty_pages;
+
+ public Book book
+ {
+ get
+ {
+ return _book;
+ }
+ set
+ {
+ if (_book != null)
+ {
+ for (var i = 0; i < _book.get_n_pages (); i++)
+ {
+ var page = _book.get_page (i);
+ on_page_removed (page);
+ }
+ _book.page_added.disconnect (on_page_added);
+ _book.page_removed.disconnect (on_page_removed);
+ _book.reordered.disconnect (on_reordered);
+ _book.cleared.disconnect (on_cleared);
+ }
+ _book = value;
+ _book.page_added.connect (on_page_added);
+ _book.page_removed.connect (on_page_removed);
+ _book.reordered.connect (on_reordered);
+ _book.cleared.connect (on_cleared);
+ for (var i = 0; i < _book.get_n_pages (); i++)
+ {
+ var page = book.get_page (i);
+ on_page_added (page);
+ }
+ }
+ }
+
+ public static AutosaveManager? create (ref Book book)
+ {
+ /* compare autosave directories with pids of current instances of simple-scan
+ * take ownership of one of the ones that are unowned by renaming to the
+ * own pid. Then open the database and fill the book with the pages it
+ * contains.
+ */
+ if (number_of_instances > 0)
+ assert_not_reached ();
+
+ var man = new AutosaveManager ();
+ number_of_instances++;
+
+ try
+ {
+ man.database_connection = open_database_connection ();
+ }
+ catch
+ {
+ warning ("Could not connect to the autosave database; no autosaves will be kept.");
+ return null;
+ }
+
+ bool any_pages_recovered = false;
+ try
+ {
+ // FIXME: this only works on linux. We can maybe use Gtk.Application and some session bus id instead?
+ string current_pids;
+ Process.spawn_command_line_sync ("pidof simple-scan | sed \"s/ /,/g\"", out current_pids);
+ current_pids = current_pids.strip ();
+ Sqlite.Statement stmt;
+ string query = @"
+ SELECT process_id, book_hash, book_revision FROM pages
+ WHERE NOT process_id IN ($current_pids)
+ LIMIT 1
+ ";
+
+ var result = man.database_connection.prepare_v2 (query, -1, out stmt);
+ if (result == Sqlite.OK)
+ {
+ while (stmt.step () == Sqlite.ROW)
+ {
+ debug ("Found at least one autosave page, taking ownership");
+ var unowned_pid = stmt.column_int (0);
+ var book_hash = stmt.column_int (1);
+ var book_revision = stmt.column_int (2);
+ /* there's a possible race condition here when several instances
+ * try to take ownership of the same rows. What would happen is
+ * that this operations would affect no rows if another process
+ * has taken ownership in the mean time. In that case, recover_book
+ * does nothing, so there should be no problem.
+ */
+ query = @"
+ UPDATE pages
+ SET process_id = $PID
+ WHERE process_id = ?2
+ AND book_hash = ?3
+ AND book_revision = ?4";
+ Sqlite.Statement stmt2;
+ result = man.database_connection.prepare_v2(query, -1, out stmt2);
+ if (result != Sqlite.OK)
+ warning (@"Error preparing statement: $query");
+
+ stmt2.bind_int64 (2, unowned_pid);
+ stmt2.bind_int64 (3, book_hash);
+ stmt2.bind_int64 (4, book_revision);
+ result = stmt2.step();
+ if (result == Sqlite.DONE)
+ {
+ any_pages_recovered = true;
+ man.recover_book (ref book);
+ }
+ else
+ warning ("Error %d while executing query", result);
+ }
+ }
+ else
+ warning ("Error %d while preparing statement", result);
+ }
+ catch (SpawnError e)
+ {
+ warning ("Could not obtain current process ids; not restoring any autosaves");
+ }
+
+ man.book = book;
+ if (!any_pages_recovered)
+ {
+ for (var i = 0; i < book.get_n_pages (); i++)
+ {
+ var page = book.get_page (i);
+ man.on_page_added (page);
+ }
+ }
+
+ return man;
+ }
+
+ private AutosaveManager ()
+ {
+ dirty_pages = new HashTable<Page, bool> (direct_hash, direct_equal);
+ }
+
+ public void cleanup ()
+ {
+ debug ("Clean exit; deleting autosave records");
+
+ if (update_timeout > 0)
+ Source.remove (update_timeout);
+ update_timeout = 0;
+
+ warn_if_fail (database_connection.exec (@"
+ DELETE FROM pages
+ WHERE process_id = $PID
+ ") == Sqlite.OK);
+ }
+
+ static Sqlite.Database open_database_connection () throws Error
+ {
+ var autosaves_dir = File.new_for_path (AUTOSAVE_DIR);
+ try
+ {
+ autosaves_dir.make_directory_with_parents ();
+ }
+ catch
+ { // the directory already exists
+ // pass
+ }
+ Sqlite.Database connection;
+ if (Sqlite.Database.open (AUTOSAVE_FILENAME, out connection) != Sqlite.OK)
+ throw new IOError.FAILED ("Could not connect to autosave database");
+ string query = @"
+ CREATE TABLE IF NOT EXISTS pages (
+ id integer PRIMARY KEY,
+ process_id integer,
+ page_hash integer,
+ book_hash integer,
+ book_revision integer,
+ page_number integer,
+ dpi integer,
+ width integer,
+ height integer,
+ depth integer,
+ n_channels integer,
+ rowstride integer,
+ color_profile string,
+ crop_x integer,
+ crop_y integer,
+ crop_width integer,
+ crop_height integer,
+ scan_direction integer,
+ pixels binary
+ )";
+ var result = connection.exec(query);
+ if (result != Sqlite.OK)
+ warning ("Error %d while executing query", result);
+ return connection;
+ }
+
+ void on_page_added (Page page)
+ {
+ insert_page (page);
+ // TODO: save a tiff file
+ page.size_changed.connect (on_page_changed);
+ page.scan_direction_changed.connect (on_page_changed);
+ page.crop_changed.connect (on_page_changed);
+ page.scan_finished.connect (on_page_changed);
+ }
+
+ public void on_page_removed (Page page)
+ {
+ page.pixels_changed.disconnect (on_page_changed);
+ page.size_changed.disconnect (on_page_changed);
+ page.scan_direction_changed.disconnect (on_page_changed);
+ page.crop_changed.disconnect (on_page_changed);
+ page.scan_finished.connect (on_page_changed);
+
+ string query = @"
+ DELETE FROM pages
+ WHERE process_id = $PID
+ AND page_hash = ?2
+ AND book_hash = ?3
+ AND book_revision = ?4
+ ";
+ Sqlite.Statement stmt;
+ var result = database_connection.prepare_v2 (query, -1, out stmt);
+ if (result != Sqlite.OK)
+ warning (@"Error $result while preparing query");
+ stmt.bind_int64 (2, direct_hash (page));
+ stmt.bind_int64 (3, direct_hash (book));
+ stmt.bind_int64 (4, cur_book_revision);
+
+ result = stmt.step();
+ if (result != Sqlite.DONE)
+ warning ("Error %d while executing query", result);
+ }
+
+ public void on_reordered ()
+ {
+ for (var i=0; i < book.get_n_pages (); i++)
+ {
+ var page = book.get_page (i);
+ string query = @"
+ UPDATE pages SET page_number = ?5
+ WHERE process_id = $PID
+ AND page_hash = ?2
+ AND book_hash = ?3
+ AND book_revision = ?4
+ ";
+ Sqlite.Statement stmt;
+ var result = database_connection.prepare_v2 (query, -1, out stmt);
+ if (result != Sqlite.OK)
+ warning (@"Error $result while preparing query");
+
+ stmt.bind_int64 (5, i);
+ stmt.bind_int64 (2, direct_hash (page));
+ stmt.bind_int64 (3, direct_hash (book));
+ stmt.bind_int64 (4, cur_book_revision);
+
+ result = stmt.step();
+ if (result != Sqlite.DONE)
+ warning ("Error %d while executing query", result);
+ }
+ }
+
+ public void on_page_changed (Page page)
+ {
+ update_page (page);
+ }
+
+ public void on_needs_saving_changed (Book book)
+ {
+ for (var n = 0; n < book.get_n_pages (); n++)
+ {
+ var page = book.get_page (n);
+ update_page (page);
+ }
+ }
+
+ private int cur_book_revision = 0;
+
+ public void on_cleared ()
+ {
+ cur_book_revision++;
+ }
+
+ private void insert_page (Page page)
+ {
+ debug ("Adding an autosave for a new page");
+ string query = @"
+ INSERT INTO pages
+ (process_id,
+ page_hash,
+ book_hash,
+ book_revision)
+ VALUES
+ ($PID,
+ ?2,
+ ?3,
+ ?4)
+ ";
+ Sqlite.Statement stmt;
+ var result = database_connection.prepare_v2 (query, -1, out stmt);
+ if (result != Sqlite.OK)
+ warning (@"Error $result while preparing query");
+
+ stmt.bind_int64 (2, direct_hash (page));
+ stmt.bind_int64 (3, direct_hash (book));
+ stmt.bind_int64 (4, cur_book_revision);
+
+ result = stmt.step();
+ if (result != Sqlite.DONE)
+ warning ("Error %d while executing query", result);
+
+ update_page (page);
+ }
+
+ private void update_page (Page page)
+ {
+ dirty_pages.insert (page, true);
+ if (update_timeout > 0)
+ Source.remove (update_timeout);
+ update_timeout = Timeout.add (100, () =>
+ {
+ var iter = HashTableIter<Page, bool> (dirty_pages);
+ Page p;
+ bool is_dirty;
+ while (iter.next (out p, out is_dirty))
+ real_update_page (p);
+
+ dirty_pages.remove_all ();
+ update_timeout = 0;
+
+ return false;
+ });
+ }
+
+ private void real_update_page (Page page)
+ {
+ debug ("Updating the autosave for a page");
+
+ int crop_x;
+ int crop_y;
+ int crop_width;
+ int crop_height;
+ page.get_crop (out crop_x, out crop_y, out crop_width, out crop_height);
+
+ Sqlite.Statement stmt;
+ string query = @"
+ UPDATE pages
+ SET
+ page_number=$(book.get_page_index (page)),
+ dpi=$(page.get_dpi ()),
+ width=$(page.get_width ()),
+ height=$(page.get_height ()),
+ depth=$(page.get_depth ()),
+ n_channels=$(page.get_n_channels ()),
+ rowstride=$(page.get_rowstride ()),
+ crop_x=$crop_x,
+ crop_y=$crop_y,
+ crop_width=$crop_width,
+ crop_height=$crop_height,
+ scan_direction=$((int)page.get_scan_direction ()),
+ color_profile=?1,
+ pixels=?2
+ WHERE process_id = $PID
+ AND page_hash = ?4
+ AND book_hash = ?5
+ AND book_revision = ?6
+ ";
+
+ var result = database_connection.prepare_v2 (query, -1, out stmt);
+ if (result != Sqlite.OK)
+ {
+ warning ("Error %d while preparing statement", result);
+ return;
+ }
+
+ stmt.bind_int64 (4, direct_hash (page));
+ stmt.bind_int64 (5, direct_hash (book));
+ stmt.bind_int64 (6, cur_book_revision);
+ result = stmt.bind_text (1, page.get_color_profile () ?? "");
+
+ if (result != Sqlite.OK)
+ warning ("Error %d while binding text", result);
+
+ if (page.get_pixels () != null)
+ {
+ // (-1) is the special value SQLITE_TRANSIENT
+ result = stmt.bind_blob (2, page.get_pixels (), page.get_pixels ().length, (DestroyNotify)(-1));
+ if (result != Sqlite.OK)
+ warning ("Error %d while binding blob", result);
+ }
+ else
+ warn_if_fail (stmt.bind_null (2) == Sqlite.OK);
+
+ warn_if_fail (stmt.step () == Sqlite.DONE);
+ }
+
+ private void recover_book (ref Book book)
+ {
+ Sqlite.Statement stmt;
+ string query = @"
+ SELECT process_id,
+ page_hash,
+ book_hash,
+ book_revision,
+ page_number,
+ dpi,
+ width,
+ height,
+ depth,
+ n_channels,
+ rowstride,
+ color_profile,
+ crop_x,
+ crop_y,
+ crop_width,
+ crop_height,
+ scan_direction,
+ pixels,
+ id
+ FROM pages
+ WHERE process_id = $PID
+ AND book_revision = (
+ SELECT MAX(book_revision) FROM pages WHERE process_id = $PID
+ )
+ ORDER BY page_number
+ ";
+
+ var result = database_connection.prepare_v2 (query, -1, out stmt);
+ if (result != Sqlite.OK)
+ warning ("Error %d while preparing statement", result);
+
+ var first = true;
+ while (Sqlite.ROW == stmt.step ())
+ {
+ debug ("Found a page that needs to be recovered");
+ if (first)
+ {
+ book.clear ();
+ first = false;
+ }
+ var dpi = stmt.column_int (5);
+ var width = stmt.column_int (6);
+ var height = stmt.column_int (7);
+ var depth = stmt.column_int (8);
+ var n_channels = stmt.column_int (9);
+ var scan_direction = (ScanDirection)stmt.column_int (16);
+
+ if (width <= 0 || height <= 0)
+ continue;
+
+ debug (@"Restoring a page of size $(width) x $(height)");
+ var new_page = book.append_page (width, height, dpi, scan_direction);
+
+ if (depth > 0 && n_channels > 0)
+ {
+ var info = new ScanPageInfo ();
+ info.width = width;
+ info.height = height;
+ info.depth = depth;
+ info.n_channels = n_channels;
+ info.dpi = dpi;
+ info.device = "";
+ new_page.set_page_info (info);
+ }
+
+ new_page.set_color_profile (stmt.column_text (11));
+ var crop_x = stmt.column_int (12);
+ var crop_y = stmt.column_int (13);
+ var crop_width = stmt.column_int (14);
+ var crop_height = stmt.column_int (15);
+ if (crop_width > 0 && crop_height > 0)
+ {
+ new_page.set_custom_crop (crop_width, crop_height);
+ new_page.move_crop (crop_x, crop_y);
+ }
+
+ uchar[] new_pixels = new uchar[stmt.column_bytes (17)];
+ Memory.copy (new_pixels, stmt.column_blob (17), stmt.column_bytes (17));
+ new_page.set_pixels (new_pixels);
+
+ var id = stmt.column_int (18);
+ debug ("Updating autosave to point to our new copy of the page");
+ query = @"
+ UPDATE pages
+ SET page_hash=?1,
+ book_hash=?2,
+ book_revision=?3
+ WHERE id = $id
+ ";
+
+ Sqlite.Statement stmt2;
+ var result2 = database_connection.prepare_v2 (query, -1, out stmt2);
+ if (result2 != Sqlite.OK)
+ warning (@"Error $result2 while preparing query");
+ stmt2.bind_int64 (1, direct_hash (new_page));
+ stmt2.bind_int64 (2, direct_hash (book));
+ stmt2.bind_int64 (3, cur_book_revision);
+
+ result2 = stmt2.step ();
+ if (result2 != Sqlite.DONE)
+ warning ("Error %d while executing query", result);
+ }
+
+ if (first)
+ debug ("No pages found to recover");
+ }
+}