summaryrefslogtreecommitdiff
path: root/src/MetadataWriter.vala
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-23 09:06:59 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-23 09:06:59 +0200
commit4ea2cc3bd4a7d9b1c54a9d33e6a1cf82e7c8c21d (patch)
treed2e54377d14d604356c86862a326f64ae64dadd6 /src/MetadataWriter.vala
Imported Upstream version 0.18.1upstream/0.18.1
Diffstat (limited to 'src/MetadataWriter.vala')
-rw-r--r--src/MetadataWriter.vala675
1 files changed, 675 insertions, 0 deletions
diff --git a/src/MetadataWriter.vala b/src/MetadataWriter.vala
new file mode 100644
index 0000000..aee5855
--- /dev/null
+++ b/src/MetadataWriter.vala
@@ -0,0 +1,675 @@
+/* Copyright 2010-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU Lesser General Public License
+ * (version 2.1 or later). See the COPYING file in this distribution.
+ */
+
+// MetadataWriter tracks LibraryPhotos for alterations to their metadata and commits those changes
+// in a timely manner to their backing files. Because only the MetadataWriter knows when the
+// metadata has been properly committed, it is also responsible for updating the metadata-dirty
+// flag in Photo. Thus, MetadataWriter should *always* be running, even if the user has turned off
+// the feature, so if they turn it on MetadataWriter can properly go out and update the backing
+// files.
+
+public class MetadataWriter : Object {
+ public const uint COMMIT_DELAY_MSEC = 3000;
+ public const uint COMMIT_SPACING_MSEC = 50;
+
+ private const string[] INTERESTED_PHOTO_METADATA_DETAILS = { "name", "comment", "rating", "exposure-time" };
+
+ private class CommitJob : BackgroundJob {
+ public LibraryPhoto photo;
+ public Gee.Set<string>? current_keywords;
+ public Photo.ReimportMasterState reimport_master_state = null;
+ public Photo.ReimportEditableState reimport_editable_state = null;
+ public Error? err = null;
+
+ public CommitJob(MetadataWriter owner, LibraryPhoto photo, Gee.Set<string>? keywords) {
+ base (owner, owner.on_update_completed, new Cancellable(), owner.on_update_cancelled);
+
+ this.photo = photo;
+ current_keywords = keywords;
+ }
+
+ public override void execute() {
+ try {
+ commit_master();
+ commit_editable();
+ } catch (Error err) {
+ this.err = err;
+ }
+ }
+
+ private void commit_master() throws Error {
+ // If we have an editable, any orientation changes should be written only to it;
+ // otherwise, we'll end up ruining the original, and as such, breaking the
+ // ability to revert to it.
+ bool skip_orientation = photo.has_editable();
+
+ if (!photo.get_master_file_format().can_write_metadata())
+ return;
+
+ PhotoMetadata metadata = photo.get_master_metadata();
+ if (update_metadata(metadata, skip_orientation)) {
+ LibraryMonitor.blacklist_file(photo.get_master_file(), "MetadataWriter.commit_master");
+ try {
+ photo.persist_master_metadata(metadata, out reimport_master_state);
+ } finally {
+ LibraryMonitor.unblacklist_file(photo.get_master_file());
+ }
+ }
+ }
+
+ private void commit_editable() throws Error {
+ if (!photo.has_editable() || !photo.get_editable_file_format().can_write_metadata())
+ return;
+
+ PhotoMetadata? metadata = photo.get_editable_metadata();
+ assert(metadata != null);
+
+ if (update_metadata(metadata)) {
+ LibraryMonitor.blacklist_file(photo.get_editable_file(), "MetadataWriter.commit_editable");
+ try {
+ photo.persist_editable_metadata(metadata, out reimport_editable_state);
+ } finally {
+ LibraryMonitor.unblacklist_file(photo.get_editable_file());
+ }
+ }
+ }
+
+ private bool update_metadata(PhotoMetadata metadata, bool skip_orientation = false) {
+ bool changed = false;
+
+ // title (caption)
+ string? current_title = photo.get_title();
+ if (current_title != metadata.get_title()) {
+ metadata.set_title(current_title);
+ changed = true;
+ }
+
+ // comment
+ string? current_comment = photo.get_comment();
+ if (current_comment != metadata.get_comment()) {
+ metadata.set_comment(current_comment);
+ changed = true;
+ }
+
+ // rating
+ Rating current_rating = photo.get_rating();
+ if (current_rating != metadata.get_rating()) {
+ metadata.set_rating(current_rating);
+ changed = true;
+ }
+
+ // exposure date/time
+ time_t current_exposure_time = photo.get_exposure_time();
+ time_t metadata_exposure_time = 0;
+ MetadataDateTime? metadata_exposure_date_time = metadata.get_exposure_date_time();
+ if (metadata_exposure_date_time != null)
+ metadata_exposure_time = metadata_exposure_date_time.get_timestamp();
+ if (current_exposure_time != metadata_exposure_time) {
+ metadata.set_exposure_date_time(current_exposure_time != 0
+ ? new MetadataDateTime(current_exposure_time)
+ : null);
+ changed = true;
+ }
+
+ // tags (keywords) ... replace (or clear) entirely rather than union or intersection
+ Gee.Set<string> safe_keywords = new Gee.HashSet<string>();
+
+ // Since the tags are stored in an image file's `keywords' field in
+ // non-hierarchical format, before checking whether the tags that
+ // should be associated with this image have been written, we'll need
+ // to produce non-hierarchical versions of the tags to be tested.
+ // get_user_visible_name() does this by returning the most deeply-nested
+ // portion of a given hierarchical tag; that is, for a tag "/a/b/c",
+ // it'll return "c", which is exactly the form we want here.
+ if (current_keywords != null) {
+ foreach(string tmp in current_keywords) {
+ Tag tag = Tag.for_path(tmp);
+ safe_keywords.add(tag.get_user_visible_name());
+ }
+ }
+
+ if (!equal_sets(safe_keywords, metadata.get_keywords())) {
+ metadata.set_keywords(current_keywords);
+ changed = true;
+ }
+
+ // orientation
+ if (!skip_orientation) {
+ Orientation current_orientation = photo.get_orientation();
+ if (current_orientation != metadata.get_orientation()) {
+ metadata.set_orientation(current_orientation);
+ changed = true;
+ }
+ }
+
+ // add the software name/version only if updating the metadata in the file
+ if (changed)
+ metadata.set_software(Resources.APP_TITLE, Resources.APP_VERSION);
+
+ return changed;
+ }
+ }
+
+ private static MetadataWriter instance = null;
+
+ private Workers workers = new Workers(1, false);
+ private bool enabled = false;
+ private HashTimedQueue<LibraryPhoto> dirty;
+ private Gee.HashMap<LibraryPhoto, CommitJob> pending = new Gee.HashMap<LibraryPhoto, CommitJob>();
+ private Gee.HashSet<string> interested_photo_details = new Gee.HashSet<string>();
+ private LibraryPhoto? ignore_photo_alteration = null;
+ private uint outstanding_total = 0;
+ private uint outstanding_completed = 0;
+ private bool closed = false;
+ private int pause_count = 0;
+ private Gee.HashSet<LibraryPhoto> importing_photos = new Gee.HashSet<LibraryPhoto>();
+
+ public signal void progress(uint completed, uint total);
+
+ private MetadataWriter() {
+ dirty = new HashTimedQueue<LibraryPhoto>(COMMIT_DELAY_MSEC, on_photo_dequeued);
+ dirty.set_dequeue_spacing_msec(COMMIT_SPACING_MSEC);
+
+ // start with the writer paused, waiting for the LibraryMonitor initial discovery to
+ // complete (note that if the LibraryMonitor is ever disabled, the MetadataWriter will not
+ // start on its own)
+ pause();
+
+ // convert all interested metadata Alteration details into lookup hash
+ foreach (string detail in INTERESTED_PHOTO_METADATA_DETAILS)
+ interested_photo_details.add(detail);
+
+ // sync up with the configuration system
+ enabled = Config.Facade.get_instance().get_commit_metadata_to_masters();
+ Config.Facade.get_instance().commit_metadata_to_masters_changed.connect(on_config_changed);
+
+ // add all current photos to look for ones that are dirty and need updating
+ force_rescan();
+
+ LibraryPhoto.global.media_import_starting.connect(on_importing_photos);
+ LibraryPhoto.global.media_import_completed.connect(on_photos_imported);
+ LibraryPhoto.global.contents_altered.connect(on_photos_added_removed);
+ LibraryPhoto.global.items_altered.connect(on_photos_altered);
+ LibraryPhoto.global.frozen.connect(on_collection_frozen);
+ LibraryPhoto.global.thawed.connect(on_collection_thawed);
+ LibraryPhoto.global.items_destroyed.connect(on_photos_destroyed);
+
+ Tag.global.items_altered.connect(on_tags_altered);
+ Tag.global.container_contents_altered.connect(on_tag_contents_altered);
+ Tag.global.backlink_to_container_removed.connect(on_tag_backlink_removed);
+ Tag.global.frozen.connect(on_collection_frozen);
+ Tag.global.thawed.connect(on_collection_thawed);
+
+ Application.get_instance().exiting.connect(on_application_exiting);
+
+ LibraryMonitorPool.get_instance().monitor_installed.connect(on_monitor_installed);
+ LibraryMonitorPool.get_instance().monitor_destroyed.connect(on_monitor_destroyed);
+ }
+
+ ~MetadataWriter() {
+ Config.Facade.get_instance().commit_metadata_to_masters_changed.disconnect(on_config_changed);
+
+ LibraryPhoto.global.media_import_starting.disconnect(on_importing_photos);
+ LibraryPhoto.global.media_import_completed.disconnect(on_photos_imported);
+ LibraryPhoto.global.contents_altered.disconnect(on_photos_added_removed);
+ LibraryPhoto.global.items_altered.disconnect(on_photos_altered);
+ LibraryPhoto.global.frozen.disconnect(on_collection_frozen);
+ LibraryPhoto.global.thawed.disconnect(on_collection_thawed);
+ LibraryPhoto.global.items_destroyed.disconnect(on_photos_destroyed);
+
+ Tag.global.items_altered.disconnect(on_tags_altered);
+ Tag.global.container_contents_altered.disconnect(on_tag_contents_altered);
+ Tag.global.backlink_to_container_removed.disconnect(on_tag_backlink_removed);
+ Tag.global.frozen.disconnect(on_collection_frozen);
+ Tag.global.thawed.disconnect(on_collection_thawed);
+
+ Application.get_instance().exiting.disconnect(on_application_exiting);
+
+ LibraryMonitorPool.get_instance().monitor_installed.disconnect(on_monitor_installed);
+ LibraryMonitorPool.get_instance().monitor_destroyed.disconnect(on_monitor_destroyed);
+ }
+
+ public static void init() {
+ instance = new MetadataWriter();
+ }
+
+ public static void terminate() {
+ if (instance != null)
+ instance.close();
+
+ instance = null;
+ }
+
+ public static MetadataWriter get_instance() {
+ return instance;
+ }
+
+ // This will examine all photos for dirty metadata and schedule commits if enabled.
+ public void force_rescan() {
+ schedule_if_dirty((Gee.Collection<LibraryPhoto>) LibraryPhoto.global.get_all(), "force rescan");
+ }
+
+ public void pause() {
+ if (pause_count++ != 0)
+ return;
+
+ dirty.pause();
+
+ progress(0, 0);
+ }
+
+ public void unpause() {
+ if (pause_count == 0 || --pause_count != 0)
+ return;
+
+ dirty.unpause();
+ }
+
+ public void close() {
+ if (closed)
+ return;
+
+ cancel_all(true);
+
+ closed = true;
+ }
+
+ private void on_config_changed() {
+ bool value = Config.Facade.get_instance().get_commit_metadata_to_masters();
+
+ if (enabled == value)
+ return;
+
+ enabled = value;
+ if (enabled)
+ force_rescan();
+ else
+ cancel_all(false);
+ }
+
+ private void on_application_exiting() {
+ close();
+ }
+
+ private void on_monitor_installed(LibraryMonitor monitor) {
+ monitor.discovery_completed.connect(on_discovery_completed);
+ }
+
+ private void on_monitor_destroyed(LibraryMonitor monitor) {
+ monitor.discovery_completed.disconnect(on_discovery_completed);
+ }
+
+ private void on_discovery_completed() {
+ unpause();
+ }
+
+ private void on_collection_frozen() {
+ pause();
+ }
+
+ private void on_collection_thawed() {
+ unpause();
+ }
+
+ private void on_importing_photos(Gee.Collection<MediaSource> media_sources) {
+ importing_photos.add_all((Gee.Collection<LibraryPhoto>) media_sources);
+ }
+
+ private void on_photos_imported(Gee.Collection<MediaSource> media_sources) {
+ importing_photos.remove_all((Gee.Collection<LibraryPhoto>) media_sources);
+ }
+
+ private void on_photos_added_removed(Gee.Iterable<DataObject>? added,
+ Gee.Iterable<DataObject>? removed) {
+ // no reason to go through this exercise if auto-commit is disabled
+ if (added != null && enabled)
+ schedule_if_dirty((Gee.Iterable<LibraryPhoto>) added, "added to LibraryPhoto.global");
+
+ // want to cancel jobs no matter what, however
+ if (removed != null) {
+ bool cancelled = false;
+ foreach (DataObject object in removed)
+ cancelled = cancel_job((LibraryPhoto) object) || cancelled;
+
+ if (cancelled)
+ progress(outstanding_completed, outstanding_total);
+ }
+ }
+
+ private void on_photos_altered(Gee.Map<DataObject, Alteration> items) {
+ Gee.HashSet<LibraryPhoto> photos = null;
+ foreach (DataObject object in items.keys) {
+ LibraryPhoto photo = (LibraryPhoto) object;
+
+ // ignore this signal on this photo (means it's coming up from completing the metadata
+ // update)
+ if (photo == ignore_photo_alteration)
+ continue;
+
+ Alteration alteration = items.get(object);
+
+ // if an image:orientation detail, write that out
+ if (alteration.has_detail("image", "orientation")) {
+ if (photos == null)
+ photos = new Gee.HashSet<LibraryPhoto>();
+
+ photos.add(photo);
+
+ continue;
+ }
+
+ // get all "metadata" details for this alteration
+ Gee.Collection<string>? details = alteration.get_details("metadata");
+ if (details == null)
+ continue;
+
+ // only enqueue an update if an alteration of metadata actually written out occurs
+ foreach (string detail in details) {
+ if (interested_photo_details.contains(detail)) {
+ if (photos == null)
+ photos = new Gee.HashSet<LibraryPhoto>();
+
+ photos.add(photo);
+
+ break;
+ }
+ }
+ }
+
+ if (photos != null)
+ photos_are_dirty(photos, "alteration", false);
+ }
+
+ private void on_photos_destroyed(Gee.Collection<DataSource> destroyed) {
+ foreach (DataSource source in destroyed) {
+ LibraryPhoto photo = (LibraryPhoto) source;
+ cancel_job(photo);
+ importing_photos.remove(photo);
+ }
+ }
+
+ private void on_tags_altered(Gee.Map<DataObject, Alteration> map) {
+ Gee.HashSet<LibraryPhoto>? photos = null;
+ foreach (DataObject object in map.keys) {
+ if (!map.get(object).has_detail("metadata", "name"))
+ continue;
+
+ if (photos == null)
+ photos = new Gee.HashSet<LibraryPhoto>();
+
+ foreach (MediaSource media in ((Tag) object).get_sources()) {
+ LibraryPhoto? photo = media as LibraryPhoto;
+ if (photo != null)
+ photos.add(photo);
+ }
+ }
+
+ if (photos != null)
+ photos_are_dirty(photos, "tag renamed", false);
+ }
+
+ private void on_tag_contents_altered(ContainerSource container, Gee.Collection<DataSource>? added,
+ bool relinking, Gee.Collection<DataSource>? removed, bool unlinking) {
+ Tag tag = (Tag) container;
+
+ if (added != null && !relinking) {
+ Gee.ArrayList<LibraryPhoto> added_photos = new Gee.ArrayList<LibraryPhoto>();
+ foreach (DataSource source in added) {
+ LibraryPhoto? photo = source as LibraryPhoto;
+ if (photo != null && !importing_photos.contains(photo))
+ added_photos.add(photo);
+ }
+
+ photos_are_dirty(added_photos, "added to %s".printf(tag.to_string()), false);
+ }
+
+ if (removed != null && !unlinking) {
+ Gee.ArrayList<LibraryPhoto> removed_photos = new Gee.ArrayList<LibraryPhoto>();
+ foreach (DataSource source in removed) {
+ LibraryPhoto? photo = source as LibraryPhoto;
+ if (photo != null)
+ removed_photos.add(photo);
+ }
+
+ photos_are_dirty(removed_photos, "removed from %s".printf(tag.to_string()), false);
+ }
+ }
+
+ private void on_tag_backlink_removed(ContainerSource container, Gee.Collection<DataSource> sources) {
+ Gee.ArrayList<LibraryPhoto> photos = new Gee.ArrayList<LibraryPhoto>();
+ foreach (DataSource source in sources) {
+ LibraryPhoto? photo = source as LibraryPhoto;
+ if (photo != null)
+ photos.add(photo);
+ }
+
+ photos_are_dirty(photos, "backlink removed from %s".printf(container.to_string()), false);
+ }
+
+ private void count_enqueued_work(int count, bool report) {
+ outstanding_total += count;
+
+#if TRACE_METADATA_WRITER
+ debug("[%u/%u] %d metadata jobs enqueued", outstanding_completed, outstanding_total, count);
+#endif
+
+ if (report)
+ progress(outstanding_completed, outstanding_total);
+ }
+
+ private void count_cancelled_work(int count, bool report) {
+ outstanding_total = (outstanding_total >= count) ? outstanding_total - count : 0;
+ if (outstanding_completed >= outstanding_total) {
+ outstanding_completed = 0;
+ outstanding_total = 0;
+ }
+
+#if TRACE_METADATA_WRITER
+ debug("[%u/%u] %d metadata jobs cancelled", outstanding_completed, outstanding_total, count);
+#endif
+
+ if (report)
+ progress(outstanding_completed, outstanding_total);
+ }
+
+ private void count_completed_work(int count, bool report) {
+ outstanding_completed += count;
+ if (outstanding_completed >= outstanding_total) {
+ outstanding_completed = 0;
+ outstanding_total = 0;
+ }
+
+#if TRACE_METADATA_WRITER
+ debug("[%u/%u] %d metadata jobs completed", outstanding_completed, outstanding_total, count);
+#endif
+
+ if (report)
+ progress(outstanding_completed, outstanding_total);
+ }
+
+ private void schedule_if_dirty(Gee.Iterable<MediaSource> media_sources, string reason) {
+ Gee.ArrayList<LibraryPhoto> photos = null;
+ foreach (MediaSource media in media_sources) {
+ LibraryPhoto? photo = media as LibraryPhoto;
+ if (photo == null)
+ continue;
+
+ // if in the importing stage, do not schedule for commit
+ if (importing_photos.contains(photo))
+ continue;
+
+ if (photo.is_master_metadata_dirty()) {
+ if (photos == null)
+ photos = new Gee.ArrayList<LibraryPhoto>();
+
+ photos.add(photo);
+ }
+ }
+
+ if (photos != null)
+ photos_are_dirty(photos, reason, true);
+ }
+
+ // No photos are dirty. The human body is a thing of beauty and grace.
+ private void photos_are_dirty(Gee.Collection<LibraryPhoto> photos, string reason, bool already_marked) {
+ if (photos.size == 0)
+ return;
+
+ // cancel all outstanding and pending jobs
+ foreach (LibraryPhoto photo in photos)
+ cancel_job(photo);
+
+ // mark all the photos as dirty
+ if (!already_marked) {
+ try {
+ LibraryPhoto.global.transaction_controller.begin();
+
+ foreach (LibraryPhoto photo in photos)
+ photo.set_master_metadata_dirty(true);
+
+ LibraryPhoto.global.transaction_controller.commit();
+ } catch (Error err) {
+ if (err is DatabaseError)
+ AppWindow.database_error((DatabaseError) err);
+ else
+ error("Unable to mark metadata as dirty: %s", err.message);
+ }
+ }
+
+ // ok to drop this on the floor, now that they're marked dirty (will attempt to write them
+ // out the next time MetadataWriter runs)
+ if (closed || !enabled)
+ return;
+
+#if TRACE_METADATA_WRITER
+ debug("[%s] adding %d photos to dirty list", reason, photos.size);
+#endif
+
+ foreach (LibraryPhoto photo in photos) {
+ bool enqueued = dirty.enqueue(photo);
+ assert(enqueued);
+ }
+
+ count_enqueued_work(photos.size, true);
+ }
+
+ private void cancel_all(bool wait) {
+ dirty.clear();
+
+ foreach (CommitJob job in pending.values)
+ job.cancel();
+
+ if (wait)
+ workers.wait_for_empty_queue();
+
+ count_cancelled_work(int.MAX, true);
+ }
+
+ private bool cancel_job(LibraryPhoto photo) {
+ bool cancelled = false;
+
+ if (pending.has_key(photo)) {
+ pending.get(photo).cancel();
+ cancelled = true;
+ }
+
+ if (dirty.contains(photo)) {
+ bool removed = dirty.remove_first(photo);
+ assert(removed);
+
+ assert(!dirty.contains(photo));
+
+ count_cancelled_work(1, false);
+ cancelled = true;
+ }
+
+ return cancelled;
+ }
+
+ private void on_photo_dequeued(LibraryPhoto photo) {
+ if (!enabled) {
+ count_cancelled_work(1, true);
+
+ return;
+ }
+
+ Gee.Set<string>? keywords = null;
+ Gee.Collection<Tag>? tags = Tag.global.fetch_for_source(photo);
+ if (tags != null) {
+ keywords = new Gee.HashSet<string>();
+ foreach (Tag tag in tags)
+ keywords.add(tag.get_name());
+ }
+
+ CommitJob job = new CommitJob(this, photo, keywords);
+ pending.set(photo, job);
+
+#if TRACE_METADATA_WRITER
+ debug("%s dequeued for metadata commit, %d pending", photo.to_string(), pending.size);
+#endif
+
+ workers.enqueue(job);
+ }
+
+ private void on_update_completed(BackgroundJob j) {
+ CommitJob job = (CommitJob) j;
+
+ if (job.err != null)
+ warning("Unable to update metadata for %s: %s", job.photo.to_string(), job.err.message);
+ else
+ message("Completed writing metadata for %s", job.photo.to_string());
+
+ bool removed = pending.unset(job.photo);
+ assert(removed);
+
+ // since there's potentially multiple state-change operations here, use the transaction
+ // controller
+ LibraryPhoto.global.transaction_controller.begin();
+
+ if (job.reimport_master_state != null || job.reimport_editable_state != null) {
+ // finish_update_*_metadata are going to issue an "altered" signal, and we want to
+ // ignore it
+ assert(ignore_photo_alteration == null);
+ ignore_photo_alteration = job.photo;
+ try {
+ if (job.reimport_master_state != null)
+ job.photo.finish_update_master_metadata(job.reimport_master_state);
+
+ if (job.reimport_editable_state != null)
+ job.photo.finish_update_editable_metadata(job.reimport_editable_state);
+ } catch (DatabaseError err) {
+ AppWindow.database_error(err);
+ } finally {
+ // this assertion guards against reentrancy
+ assert(ignore_photo_alteration == job.photo);
+ ignore_photo_alteration = null;
+ }
+ } else {
+#if TRACE_METADATA_WRITER
+ debug("[%u/%u] No metadata changes for %s", outstanding_completed, outstanding_total,
+ job.photo.to_string());
+#endif
+ }
+
+ try {
+ job.photo.set_master_metadata_dirty(false);
+ } catch (DatabaseError err) {
+ AppWindow.database_error(err);
+ }
+
+ LibraryPhoto.global.transaction_controller.commit();
+
+ count_completed_work(1, true);
+ }
+
+ private void on_update_cancelled(BackgroundJob j) {
+ bool removed = pending.unset(((CommitJob) j).photo);
+ assert(removed);
+
+ count_cancelled_work(1, true);
+ }
+}
+