/* Part of SWI-Prolog Author: Jan Wielemaker E-mail: J.Wielemaker@vu.nl WWW: http://www.swi-prolog.org Copyright (c) 2003-2013, University of Amsterdam VU University Amsterdam All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ :- module(rdf_edit, [ rdfe_assert/3, % Sub, Pred, Obj rdfe_assert/4, % Sub, Pred, Obj, PayLoad rdfe_retractall/3, % Sub, Pred, Obj rdfe_retractall/4, % Sub, Pred, Obj, PayLoad rdfe_update/4, % Sub, Pred, Obj, +Action rdfe_update/5, % Sub, Pred, Obj, +PayLoad, +Action rdfe_load/1, % +File rdfe_load/2, % +File, +Options rdfe_delete/1, % +Resource rdfe_register_ns/2, % +Id, +URI rdfe_unregister_ns/2, % +Id, +URI rdfe_reset/0, % clear everything rdfe_transaction/1, % :Goal rdfe_transaction/2, % :Goal, +Name rdfe_transaction_member/2, % +Transactions, -Action rdfe_transaction_name/2, % +Transactions, -Name rdfe_set_transaction_name/1,% +Name rdfe_set_watermark/1, % +Name rdfe_undo/0, % rdfe_redo/0, rdfe_can_undo/1, % -TID rdfe_can_redo/1, % -TID rdfe_set_file_property/2, % +File, +Property rdfe_get_file_property/2, % ?File, ?Property rdfe_is_modified/1, % ?File rdfe_clear_modified/1, % +File rdfe_open_journal/2, % +File, +Mode rdfe_close_journal/0, rdfe_replay_journal/1, % +File rdfe_current_journal/1, % -Path rdfe_snapshot_file/1 % -File ]). :- use_module(rdf_db). :- use_module(library(broadcast)). :- use_module(library(lists)). :- use_module(library(debug)). :- use_module(library(uri)). :- meta_predicate rdfe_transaction(0), rdfe_transaction(0, +). :- predicate_options(rdfe_load/2, 2, [pass_to(rdf_db:rdf_load/2, 2)]). :- dynamic undo_log/5, % TID, Action, Subj, Pred, Obj current_transaction/1, % TID transaction_name/2, % TID, Name undo_marker/2, % Mode, TID journal/3, % Path, Mode, Stream snapshot_file/1. % File /** RDF edit layer This library provides a number of functions on top of the rdf_db module: * Broadcast modifications * Provide undo/redo @tbd This library must be rewritten using rdf_monitor/3. This allows using edit layer without having to choose between rdf_ and rdfe_ predicates. @see rdf_persistency.pl provides reliable persistency, but without changes boardcasting and undo/redo. */ :- rdf_meta rdfe_assert(r,r,o), rdfe_assert(r,r,o,+), rdfe_retractall(r,r,o), rdfe_update(r,r,o,t), rdfe_delete(r), rdfe_transaction(:), rdfe_transaction(:, +). /******************************* * BASIC EDIT OPERATIONS * *******************************/ rdfe_assert(Subject, Predicate, Object) :- rdfe_assert(Subject, Predicate, Object, user). rdfe_assert(Subject, Predicate, Object, PayLoad) :- rdf_assert(Subject, Predicate, Object, PayLoad), rdfe_current_transaction(TID), assert_action(TID, assert(PayLoad), Subject, Predicate, Object), journal(assert(TID, Subject, Predicate, Object, PayLoad)). rdfe_retractall(Subject, Predicate, Object) :- rdfe_retractall(Subject, Predicate, Object, _). rdfe_retractall(Subject, Predicate, Object, PayLoad) :- rdfe_current_transaction(TID), ( rdf(Subject, Predicate, Object, PayLoad), assert_action(TID, retract(PayLoad), Subject, Predicate, Object), journal(retract(TID, Subject, Predicate, Object, PayLoad)), fail ; true ), rdf_retractall(Subject, Predicate, Object, PayLoad). %! rdfe_update(+Subject, +Predicate, +Object, +Action) % % Update an existing triple. Possible actions are: % %! subject(+Subject) %! predicate(+Predicate) %! object(+Object) %! source(+Source) rdfe_update(Subject, Predicate, Object, Action) :- rdfe_current_transaction(TID), rdf_update(Subject, Predicate, Object, Action), ( Action = object(New) -> assert_action(TID, object(Object), Subject, Predicate, New) ; Action = predicate(New) -> assert_action(TID, predicate(Predicate), Subject, New, Object) ; Action = subject(New) -> assert_action(TID, subject(Subject), New, Predicate, Object) ; Action = source(New) -> forall(rdf(Subject, Predicate, Object, PayLoad), assert_action(TID, source(PayLoad, New), Subject, Predicate, Object)) ), journal(update(TID, Subject, Predicate, Object, Action)). rdfe_update(Subject, Predicate, Object, PayLoad, Action) :- rdfe_current_transaction(TID), rdf_update(Subject, Predicate, Object, PayLoad, Action), ( Action = source(New) -> assert_action(TID, source(PayLoad, New), Subject, Predicate, Object) ; throw(tbd) % source is used internally ), journal(update(TID, Subject, Predicate, Object, PayLoad, Action)). %! rdfe_delete(+Subject) % % Delete a subject and all we know about it. This is a bit tricky. % If we are involved in transitive relations, should we re-joint % these in this module? rdfe_delete(Subject) :- rdfe_transaction(delete(Subject)). delete(Subject) :- rdfe_retractall(Subject, _, _), rdfe_retractall(_, Subject, _), rdfe_retractall(_, _, Subject). /******************************* * FILE HANDLING * *******************************/ %! rdfe_load(+File) is det. %! rdfe_load(+File, +Options) is det. % % Load an RDF file and record this action including version information % to facilitate reliable reload. rdfe_load(File) :- rdfe_load(File, []). rdfe_load(File, Options) :- rdfe_current_transaction(TID), absolute_file_name(File, [ access(read), extensions([rdf,rdfs,owl,'']) ], Path), rdf_load(Path, [ graph(Graph), modified(Modified) | Options ]), ( Modified == not_modified -> true ; absolute_file_name('.', PWD), size_file(Path, Size), ( Modified = last_modified(Stamp) -> true ; time_file(Path, Stamp) ), SecTime is round(Stamp), rdf_statistics(triples_by_graph(Graph, Triples)), rdf_md5(Graph, MD5), assert_action(TID, load_file(Path), -, -, -), journal(rdf_load(TID, Path, [ pwd(PWD), size(Size), modified(SecTime), triples(Triples), md5(MD5), from(File) ])), ensure_snapshot(Path) ). rdfe_unload(Path) :- rdfe_current_transaction(TID), rdf_unload(Path), assert_action(TID, unload_file(Path), -, -, -), journal(rdf_unload(TID, Path)). %! ensure_snapshot(+Path) % % Ensure we have a snapshot of Path if we are making a journal, so % we can always reload the snapshot to ensure exactly the same % state. ensure_snapshot(Path) :- rdfe_current_journal(_), rdf_md5(Path, MD5), ( snapshot_file(Path, MD5, [ access(read), file_errors(fail) ], File) -> debug(snapshot, 'Existing snapshot for ~w on ~w', [Path, File]) ; snapshot_file(Path, MD5, [ access(write) ], File), debug(snapshot, 'Saving snapshot for ~w to ~w', [Path, File]), rdf_save_db(File, Path) ), assert(snapshot_file(File)). ensure_snapshot(_). %! load_snapshot(+Source, +Path) % % Load triples from the given snapshot file. One of the troubles % is the time-stamp to avoid rdf_make/0 from reloading the file. % for the time being we use 1e12, which is a lot further in the % future than this system is going to live. load_snapshot(Source, Path) :- statistics(cputime, T0), rdf_load_db(Path), statistics(cputime, T1), Time is T1 - T0, rdf_statistics(triples_by_graph(Source, Triples)), rdf_md5(Source, MD5), % 1e10: modified far in the future assert(rdf_db:rdf_source(Source, 1e12, Triples, MD5)), print_message(informational, rdf(loaded(Source, Triples, snapshot(Time)))), assert(snapshot_file(Path)). %! snapshot_file(+Path, +MD5, +Access, -File) % % Find existing snapsnot file or location to save a new one. snapshot_file(Path, MD5, Options, SnapShot) :- file_base_name(Path, Base), atomic_list_concat([Base, @, MD5], File), absolute_file_name(snapshot(File), [ extensions([trp]) | Options ], SnapShot). %! rdfe_snapshot_file(-File) % % Enumerate the MD5 snapshot files required to restore the current % journal file. Using this call we can write a routine that % packages the journal file with all required snapshots to restore % the journal on another computer. rdfe_snapshot_file(File) :- snapshot_file(File). /******************************* * NAMESPACE HANDLING * *******************************/ :- dynamic system_ns/2. :- volatile system_ns/2. %! rdfe_register_ns(Id, URI) % % Encapsulation of rdf_register_ns(Id, URI) rdfe_register_ns(Id, URI) :- rdf_db:ns(Id, URI), !. rdfe_register_ns(Id, URI) :- save_system_ns, rdfe_current_transaction(TID), rdf_register_ns(Id, URI), broadcast(rdf_ns(register(Id, URI))), assert_action(TID, ns(register(Id, URI)), -, -, -), journal(ns(TID, register(Id, URI))). rdfe_unregister_ns(Id, URI) :- save_system_ns, rdfe_current_transaction(TID), retractall(rdf_db:ns(Id, URI)), broadcast(rdf_ns(unregister(Id, URI))), assert_action(TID, ns(unregister(Id, URI)), -, -, -), journal(ns(TID, unregister(Id, URI))). % rdfe_register_ns/0 % % Reset namespaces to the state they where before usage of the % rdf_edit layer. rdfe_reset_ns :- ( system_ns(_, _) -> retractall(rdf_db:ns(Id, URI)), forall(system_ns(Id, URI), assert(rdb_db:ns(Id, URI))) ; true ). save_system_ns :- system_ns(_, _), !. % already done save_system_ns :- forall(rdf_db:ns(Id, URI), assert(system_ns(Id, URI))). /******************************* * TRANSACTIONS * *******************************/ %! rdfe_transaction(:Goal) % % Run Goal, recording all modifications as a single transaction. % If Goal raises an exception or fails, all changes are % rolled-back. rdfe_transaction(Goal) :- rdfe_transaction(Goal, []). rdfe_transaction(Goal, Name) :- rdfe_begin_transaction(Name), ( catch(Goal, E, true) -> ( var(E) -> check_file_protection(Error), ( var(Error) -> rdfe_commit ; rdfe_rollback, throw(Error) ) ; rdfe_rollback, throw(E) ) ; rdfe_rollback, fail ). %! rdfe_begin_transaction % % Start a transaction. This is followed by either rdfe_end_transaction % or rdfe_rollback. Transactions may be nested. rdfe_begin_transaction(Name) :- current_transaction(TID), % nested transaction !, append(TID, [1], TID2), asserta(current_transaction(TID2)), assert(transaction_name(TID2, Name)). rdfe_begin_transaction(Name) :- % toplevel transaction flag(rdf_edit_tid, TID, TID+1), asserta(current_transaction([TID])), assert(transaction_name(TID, Name)). rdfe_current_transaction(TID) :- current_transaction(TID), !. rdfe_current_transaction(_) :- throw(error(existence_error(rdf_transaction, _), _)). rdfe_commit :- retract(current_transaction(TID)), !, retractall(undo_marker(_, _)), ( rdfe_transaction_member(TID, _) -> get_time(Time), % transaction is not empty journal(commit(TID, Time)), ( TID = [Id] -> broadcast(rdf_transaction(Id)) ; true ) ; true ). rdfe_rollback :- retract(current_transaction(TID)), !, journal(rollback(TID)), rollback(TID). %! rollback(+TID) % % This is the same as undo/1, but it must not record the undone % actions as rollbacks cannot be `redone'. Somehow there should % be a cleaner way to distinguish between transactional operations % and plain operations. rollback(TID) :- append(TID, _, Id), ( retract(undo_log(Id, Action, Subject, Predicate, Object)), ( rollback(Action, Subject, Predicate, Object) -> fail ; print_message(error, rdf_undo_failed(undo(Action, Subject, Predicate, Object))), fail ) ; true ). rollback(assert(PayLoad), Subject, Predicate, Object) :- !, rdf_retractall(Subject, Predicate, Object, PayLoad). rollback(retract(PayLoad), Subject, Predicate, Object) :- !, rdf_assert(Subject, Predicate, Object, PayLoad). rollback(Action, Subject, Predicate, Object) :- action(Action), !, rdf_update(Subject, Predicate, Object, Action). assert_action(TID, Action, Subject, Predicate, Object) :- asserta(undo_log(TID, Action, Subject, Predicate, Object)). %! undo(+TID) % % Undo a transaction as well as possible transactions nested into % it. undo(TID) :- append(TID, _, Id), ( retract(undo_log(Id, Action, Subject, Predicate, Object)), ( undo(Action, Subject, Predicate, Object) -> fail ; print_message(warning, rdf_undo_failed(undo(Action, Subject, Predicate, Object))), fail ) ; true ). undo(assert(PayLoad), Subject, Predicate, Object) :- !, rdfe_retractall(Subject, Predicate, Object, PayLoad). undo(retract(PayLoad), Subject, Predicate, Object) :- !, rdfe_assert(Subject, Predicate, Object, PayLoad). undo(source(Old, New), Subject, Predicate, Object) :- !, rdfe_update(Subject, Predicate, Object, Old, source(New)). undo(ns(Action), -, -, -) :- !, ( Action = register(Id, URI) -> rdfe_unregister_ns(Id, URI) ; Action = unregister(Id, URI) -> rdfe_register_ns(Id, URI) ). undo(load_file(Path), -, -, -) :- !, rdfe_unload(Path). undo(unload_file(Path), -, -, -) :- !, rdfe_load(Path). undo(Action, Subject, Predicate, Object) :- action(Action), !, rdfe_update(Subject, Predicate, Object, Action). action(subject(_)). action(predicate(_)). action(object(_)). %! rdfe_undo % % Undo a (toplevel) transaction. More calls do further undo. The % `Undone' actions are re-added to the undo log, so the user can % redo them. Fails if there are no more undo/redo transactions. rdfe_undo :- undo_marker(undo, TID), !, ( undo_previous(TID, UnDone) -> retractall(undo_marker(_, _)), assert(undo_marker(undo, UnDone)), broadcast(rdf_undo(undo, UnDone)) ; fail % start of undo log ). rdfe_undo :- retract(undo_marker(redo, _)), !, last_transaction(TID), undo_previous(TID, UnDone), assert(undo_marker(undo, UnDone)), broadcast(rdf_undo(undo, UnDone)). rdfe_undo :- last_transaction(TID), undo_previous(TID, UnDone), assert(undo_marker(undo, UnDone)), broadcast(rdf_undo(undo, UnDone)). find_previous_undo(-1, _) :- !, fail. find_previous_undo(TID, TID) :- undo_log([TID|_], _, _, _, _), !. find_previous_undo(TID0, TID) :- TID1 is TID0 - 1, find_previous_undo(TID1, TID). undo_previous(TID, Undone) :- find_previous_undo(TID, Undone), rdfe_transaction(undo([Undone])). last_transaction(TID) :- undo_log([TID|_], _, _, _, _), !. %! rdfe_redo % % Start a redo-session rdfe_redo :- ( retract(undo_marker(undo, _)) -> last_transaction(TID), undo_previous(TID, UnDone), assert(undo_marker(redo, UnDone)), broadcast(rdf_undo(redo, UnDone)) ; retract(undo_marker(redo, TID)) -> undo_previous(TID, UnDone), assert(undo_marker(redo, UnDone)), broadcast(rdf_undo(redo, UnDone)) ; true ). %! rdfe_can_redo(-TID) is semidet. %! rdfe_can_undo(-TID) is semidet. % % Check if we can undo and if so return the id of the transaction % that will be un/re-done. A subsequent call to rdfe_transaction_name % can be used to give a hint in the UI. rdfe_can_redo(Redo) :- undo_marker(undo, _), !, last_transaction(TID), find_previous_undo(TID, Redo). rdfe_can_redo(Redo) :- undo_marker(redo, TID), find_previous_undo(TID, Redo). rdfe_can_undo(Undo) :- % continue undo undo_marker(undo, TID), !, find_previous_undo(TID, Undo). rdfe_can_undo(Undo) :- % start undo last_transaction(TID), find_previous_undo(TID, Undo). %! rdfe_transaction_name(+TID, -Name) % % Return name if the transaction is named. rdfe_transaction_name(TID, Name) :- transaction_name(TID, Name), Name \== []. %! rdfe_set_transaction_name(+Name) % % Set name of the current transaction rdfe_set_transaction_name(Name) :- current_transaction(TID), !, assert(transaction_name(TID, Name)). %! rdfe_transaction_member(+TID, -Action) % % Query actions inside a transaction to allow for quick update % of visualisers. rdfe_transaction_member(TID, Member) :- ( integer(TID) -> Id = [TID|_] ; append(TID, _, Id) ), undo_log(Id, Action, Subject, Predicate, Object), user_transaction_member(Action, Subject, Predicate, Object, Member). user_transaction_member(assert(_), Subject, Predicate, Object, assert(Subject, Predicate, Object)) :- !. user_transaction_member(retract(_), Subject, Predicate, Object, retract(Subject, Predicate, Object)) :- !. user_transaction_member(load_file(Path), -, -, -, file(load(Path))) :- !. user_transaction_member(unload_file(Path), -, -, -, file(unload(Path))) :- !. user_transaction_member(Update, Subject, Predicate, Object, update(Subject, Predicate, Object, Update)). /******************************* * PROTECTION * *******************************/ :- dynamic rdf_source_permission/2, % file, ro/rw rdf_current_default_file/2. % file, all/fallback %! rdfe_set_file_property(+File, +Options) % % Set properties on the file. Options is one of % % * access(ro/rw) % * default(all/fallback) rdfe_set_file_property(File, access(Access)) :- !, to_uri(File, URL), retractall(rdf_source_permission(URL, _)), assert(rdf_source_permission(URL, Access)), broadcast(rdf_file_property(URL, access(Access))). rdfe_set_file_property(File, default(Type)) :- to_uri(File, URL), rdfe_set_file_property(URL, access(rw)), % must be writeable retractall(rdf_current_default_file(_,_)), assert(rdf_current_default_file(URL, Type)), broadcast(rdf_file_property(URL, default(Type))). %! rdfe_get_file_property(+FileOrURL, ?Option). %! rdfe_get_file_property(-URL, ?Option). % % Fetch file properties set with rdfe_set_file_property/2. rdfe_get_file_property(FileOrURL, access(Access)) :- ( ground(FileOrURL) -> to_uri(FileOrURL, URL) ; rdf_source(_DB, URL), FileOrURL = URL ), ( rdf_source_permission(URL, Access0) -> Access0 = Access ; access_file(URL, write) -> assert(rdf_source_permission(URL, rw)), Access = rw ; assert(rdf_source_permission(URL, ro)), Access = ro ). rdfe_get_file_property(FileOrURL, default(Default)) :- ground(FileOrURL), to_uri(FileOrURL, URL), ( rdf_current_default_file(URL, Default) -> true ; FileOrURL = user, Default = fallback ). rdfe_get_file_property(URL, default(Default)) :- ( rdf_current_default_file(URL, Default) -> true ; URL = user, Default = fallback ). %! check_file_protection(-Error) % % Check modification of all protected files check_file_protection(Error) :- ( rdfe_get_file_property(File, access(ro)), rdfe_is_modified(File) -> Error = error(permission_error(modify, source, File), triple20) ; true ). %! to_uri(+Spec, -URL) is det. % % Convert a specification into a URL. to_uri(URL, URL) :- uri_components(URL, Components), uri_data(scheme, Components, Scheme), nonvar(Scheme), uri_scheme(Scheme), !. to_uri(File, URL) :- uri_file_name(URL, File). uri_scheme(file). uri_scheme(http). uri_scheme(https). uri_scheme(ftp). uri_scheme(ftps). /******************************* * MODIFIED * *******************************/ %! rdfe_is_modified(?Source) % % True if facts have been added, deleted or updated that have % Source as `payload'. rdfe_is_modified(Source) :- rdf_source(Graph, Source), rdf_graph_property(Graph, modified(true)). rdfe_clear_modified :- forall(rdf_graph(File), rdfe_clear_modified(File)). %! rdfe_clear_modified(+Graph) is det. % % Consider the current state of Graph as _unmodified_. rdfe_clear_modified(Graph) :- rdf_set_graph(Graph, modified(false)). /******************************* * WATERMARKS * *******************************/ %! rdfe_set_watermark(Name) % % Create a watermark for undo and replay journal upto this point. % The rest of the logic needs to be written later. rdfe_set_watermark(Name) :- rdfe_current_transaction(TID), assert_action(TID, watermark(Name), -, -, -), journal(watermark(TID, Name)). /******************************* * RESET * *******************************/ %! rdfe_reset % % Clear database, undo, namespaces and journalling info. rdfe_reset :- rdfe_reset_journal, rdfe_reset_ns, rdfe_reset_undo, rdf_reset_db, broadcast(rdf_reset). %! rdfe_reset_journal % % If a journal is open, close it using rdfe_close_journal/0 rdfe_reset_journal :- ( rdfe_current_journal(_) -> rdfe_close_journal ; true ). rdfe_reset_undo :- retractall(undo_log(_,_,_,_,_)), retractall(current_transaction(_)), retractall(transaction_name(_,_)), retractall(undo_marker(_,_)), retractall(snapshot_file(_)). % close possible open journal at exit. Using a Prolog hook % guarantees closure, even for most crashes. :- at_halt(rdfe_reset_journal). /******************************* * JOURNALLING * *******************************/ journal_version(1). %! rdfe_open_journal(+File, +Mode) is det. % % Open a journal writing to File in Mode. Mode is one of % % * read % Open and replay the journal % % * write % Delete current journal and create a fresh one % % * append % Read and replay the existing journal and append new % modifications to the File. rdfe_open_journal(_, _) :- % already open journal(_, _, _), !. rdfe_open_journal(File, read) :- !, absolute_file_name(File, [ extensions([rdfj, '']), access(read) ], Path), rdfe_replay_journal(Path), rdfe_clear_modified. rdfe_open_journal(File, write) :- !, absolute_file_name(File, [ extensions([rdfj, '']), access(write) ], Path), open(Path, write, Stream, [close_on_abort(false)]), assert(journal(Path, write, Stream)), get_time(T), journal_open(start, T). rdfe_open_journal(File, append) :- working_directory(CWD, CWD), absolute_file_name(File, [ extensions([rdfj, '']), relative_to(CWD), access(write) ], Path), ( exists_file(Path) -> rdfe_replay_journal(Path), rdfe_clear_modified, get_time(T), assert(journal(Path, append(T), [])) ; rdfe_open_journal(Path, write) ). journal_open(Type, Time) :- journal_comment(Type, Time), SecTime is round(Time), journal_version(Version), Start =.. [ Type, [ time(SecTime), version(Version) ] ], journal(Start), broadcast(rdf_journal(Start)). journal_comment(start, Time) :- journal(_, _, Stream), format_time(string(String), '%+', Time), format(Stream, '/* Triple20 Journal File\n\n \c Created: ~w\n \c Triple20 by Jan Wielemaker \n\n \c EDIT WITH CARE!\n\c */~n~n', [String]). journal_comment(resume, Time) :- journal(_, _, Stream), format_time(string(String), '%+', Time), format(Stream, '\n\c /* Resumed: ~w\n\c */~n~n', [String]). %! rdfe_close_journal % % Close the journal. Automatically called from at program % termination from at_halt/1. rdfe_close_journal :- get_time(T), SecTime is round(T), journal(end([ time(SecTime) ])), retract(journal(_, Mode, Stream)), ( Mode = append(_) -> true ; close(Stream) ). %! rdfe_current_journal(-Path) % % Query the currently open journal rdfe_current_journal(Path) :- journal(Path, _Mode, _Stream). journal(Term) :- journal(Path, append(T), _), !, ( Term = end(_) -> true ; open(Path, append, Stream, [close_on_abort(false)]), retractall(journal(Path, _, _)), assert(journal(Path, append, Stream)), journal_open(resume, T), journal(Term) ). journal(Term) :- ( journal(_, _, Stream) -> write_journal(Term, Stream), flush_output(Stream) ; broadcast(rdf_no_journal(Term)) ). write_journal(commit(TID, Time), Stream) :- !, format(Stream, 'commit(~q, ~2f).~n~n', [TID, Time]). write_journal(Term, Stream) :- format(Stream, '~q.~n', [Term]). %! rdfe_replay_journal(+File) % % Replay a journal file. For now this is our cheap way to deal % with save/load. Future versions may be more clever when dealing % with the version information stored in the journal. rdfe_replay_journal(File) :- absolute_file_name(File, [ extensions([rdfj, '']), access(read) ], Path), open(Path, read, Stream), replay(Stream), close(Stream). replay(Stream) :- read(Stream, Term), replay(Term, Stream). replay(end_of_file, _) :- !. replay(start(_Attributes), Stream) :- !, read(Stream, Term), replay(Term, Stream). replay(resume(_Attributes), Stream) :- !, read(Stream, Term), replay(Term, Stream). replay(end(_Attributes), Stream) :- !, read(Stream, Term), replay(Term, Stream). replay(Term0, Stream) :- replay_transaction(Term0, Stream), read(Stream, Term), replay(Term, Stream). replay_transaction(Term0, Stream) :- collect_transaction(Term0, Stream, Transaction, Last), ( committed_transaction(Last) -> replay_actions(Transaction) ; true ). collect_transaction(End, _, [], End) :- ends_transaction(End), !. collect_transaction(A, Stream, [A|T], End) :- read(Stream, Term), collect_transaction(Term, Stream, T, End). committed_transaction(commit(_)). committed_transaction(commit(_, _)). ends_transaction(end_of_file). ends_transaction(commit(_)). ends_transaction(commit(_, _)). ends_transaction(rollback(_)). ends_transaction(end(_)). ends_transaction(start(_)). replay_actions([]). replay_actions([H|T]) :- ( replay_action(H) -> replay_actions(T) ; print_message(warning, rdf_replay_failed(H)), ( debugging(journal) -> gtrace, replay_actions([H|T]) ; replay_actions(T) ) ). %! replay_action(+Action) % % Replay actions from the journal. Tricky is rdf_load/3. It should % reload the file in the state it was in at the moment it was % created. For now this has been hacked for files that were empry % at the moment they where loaded (e.g. created from `new_file' in % our GUI prototype). How to solve this? We could warn if the file % appears changed, but this isn't really easy as copying and OS % differences makes it hard to decide on changes by length as well % as modification time. Alternatively we could save the state in % seperate quick-load states. replay_action(retract(_, Subject, Predicate, Object, PayLoad)) :- rdf_retractall(Subject, Predicate, Object, PayLoad). replay_action(assert(_, Subject, Predicate, Object, PayLoad)) :- rdf_assert(Subject, Predicate, Object, PayLoad). replay_action(update(_, Subject, Predicate, Object, Action)) :- rdf_update(Subject, Predicate, Object, Action). replay_action(update(_, Subject, Predicate, Object, Payload, Action)) :- rdf_update(Subject, Predicate, Object, Payload, Action). replay_action(rdf_load(_, File, Options)) :- memberchk(md5(MD5), Options), snapshot_file(File, MD5, [ access(read), file_errors(fail) ], Path), !, debug(snapshot, 'Reloading snapshot ~w~n', [Path]), load_snapshot(File, Path). replay_action(rdf_load(_, File, Options)) :- find_file(File, Options, Path), ( memberchk(triples(0), Options), memberchk(modified(Modified), Options) -> rdf_retractall(_,_,_,Path:_), retractall(rdf_db:rdf_source(Path, _, _, _)), % TBD: move rdf_md5(Path, MD5), assert(rdf_db:rdf_source(Path, Modified, 0, MD5)) ; rdf_load(Path) ). replay_action(rdf_unload(_, Source)) :- rdf_unload(Source). replay_action(ns(_, register(ID, URI))) :- !, rdf_register_ns(ID, URI). replay_action(ns(_, unregister(ID, URI))) :- retractall(rdf_db:ns(ID, URI)). replay_action(watermark(_, _Name)) :- true. find_file(File, _, File) :- exists_file(File), !. find_file(File, Options, Path) :- memberchk(pwd(PWD), Options), make_path(File, PWD, Path), exists_file(Path), !. %! make_path(+File, +PWD, -Path) % % Return location of File relative to PWD, Parent of PWD, etc. (TBD) make_path(File, PWD, Path) :- atom_concat(PWD, /, PWD2), atom_concat(PWD2, Path, File). /******************************* * MESSAGES * *******************************/ :- multifile prolog:message/3, user:message_hook/3. % Catch messages. prolog:message(rdf_replay_failed(Term)) --> [ 'RDFDB: Replay of ~p failed'-[Term] ]. prolog:message(rdf_undo_failed(Term)) --> [ 'RDFDB: Undo of ~p failed'-[Term] ].