5 ;;; Safely modify collections of files
7 ;;; (c) 2005 Straylight/Edgeware
10 ;;;----- Licensing notice ---------------------------------------------------
12 ;;; This program is free software; you can redistribute it and/or modify
13 ;;; it under the terms of the GNU General Public License as published by
14 ;;; the Free Software Foundation; either version 2 of the License, or
15 ;;; (at your option) any later version.
17 ;;; This program is distributed in the hope that it will be useful,
18 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;;; GNU General Public License for more details.
22 ;;; You should have received a copy of the GNU General Public License
23 ;;; along with this program; if not, write to the Free Software Foundation,
24 ;;; Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 (:use #:common-lisp #:mdw.base)
28 (:export #:safely #:safely-close #:safely-delete-file
29 #:safely-open-output-stream #:safely-bail #:safely-commit
34 (eval-when (:compile-toplevel :execute)
35 (import #+cmu '(ext:unix-namestring unix:unix-link)
36 #+sbcl '(sb-int:unix-namestring)))
38 (defstruct (safely (:predicate safelyp))
39 "Stores information about how to commit or undo safe writes."
43 (defun safely-close (safe stream)
44 "Make sure that STREAM is closed when SAFE is finished."
45 (push stream (safely-streams safe)))
47 (defun safely-delete-file (safe file)
48 "Delete FILE when SAFE is committed."
49 (push `(:delete ,file) (safely-trail safe)))
51 (defun generate-fresh-file-name (base tag &optional func)
52 "Return a fresh file name constructed from BASE (a filespec) and TAG (some
53 short descriptive string). The generated name has the same directory and
54 type as the BASE name, but a different name.
56 If FUNC is non-nil, then it is a function to call on the generated file
57 name: generate-fresh-file-name runs in a loop, calling FUNC with generated
58 file names until FUNC returns non-nil, at which point generate-fresh-
59 file-name returns two values: the generated name, and the result of FUNC.
60 generate-fresh-file-name catches errors of type file-error from FUNC, and
61 just tries again with a new name.
63 If FUNC is nil, it's treated the same as a function which always returns
66 This is inspired by a similar facility in scsh."
67 (let ((base (pathname base)))
69 (error "Gave up trying to find a temporary ~A file for ~S."
71 (let* ((new (merge-pathnames
73 :name (format nil "~A-~A-~X"
76 (random most-positive-fixnum)))
78 (ret (and (not (probe-file new))
80 (handler-case (funcall func new)
82 (unless (pathname-match-p
83 (file-error-pathname cond)
89 (return (values new ret)))))))
91 (defun safely-open-output-stream (safe file &rest open-args)
92 "Create an output stream which will be named FILE when SAFE is committed.
93 Other OPEN-ARGS are passed to open."
96 (generate-fresh-file-name file "new"
102 (safely-close safe stream)
103 (push `(:shunt ,name ,file)
107 (declaim (inline rename))
108 (defun rename (old new)
109 #-clisp (rename-file old new)
110 #+clisp (posix:copy-file old new :method :rename))
112 (defun delete-file-without-moaning (file)
113 "Delete the FILE, ignoring errors."
114 (handler-case (delete-file file)
115 (file-error () nil)))
117 (defun rename-file-without-moaning (old new)
118 "Rename OLD to NEW, ignoring errors, and without doing any stupid name
120 (handler-case (rename old new)
121 (file-error () nil)))
123 (defun safely-unwind (trail)
124 "Roll back the TRAIL of operations."
127 (:shunt (destructuring-bind (new file) (cdr job)
128 (declare (ignore file))
129 (delete-file-without-moaning new)))
131 (:rmtmp (destructuring-bind (file) (cdr job)
132 (delete-file-without-moaning file)))
133 (:revert (destructuring-bind (old new) (cdr job)
134 (rename-file-without-moaning old new))))))
136 (defun safely-reset (safe)
137 "Reset SAFE to its initial state."
138 (setf (safely-streams safe) nil)
139 (setf (safely-trail safe) nil))
141 (defun safely-bail (safe)
142 "Abort the operations in SAFE, unwinding all the things that have been
143 done. Streams are closed, new files are removed."
144 (dolist (stream (safely-streams safe))
145 (close stream :abort t))
146 (safely-unwind (safely-trail safe))
150 (defun unix-link (from to)
151 (sb-unix::int-syscall ("link" sb-alien:c-string sb-alien:c-string)
154 (defun safe-copy (file tag)
155 "Make a copy of the FILE. Return the new name."
158 ;; Use link(2) where available.
159 (generate-fresh-file-name file tag
161 (let ((from (unix-namestring file t))
162 (to (unix-namestring name nil)))
164 (unix-link from to)))))
167 (generate-fresh-file-name file tag
169 (posix:copy-file (namestring file)
177 ;; Otherwise just copy the file contents and hope for the best.
178 (with-open-file (input file :element-type :default)
181 (generate-fresh-file-name file tag
186 :element-type :default)))
189 (let ((buffer (make-array 8192
190 :element-type (stream-element-type
193 (let ((read (read-sequence buffer input)))
195 (write-sequence buffer output :end read))
196 (when (< read (length buffer))
200 (defun safely-commit (safe)
201 "Commit SAFE. The files deleted by safely-delete-file are deleted; the
202 files created by safely-open-output-stream are renamed over the old
203 versions, if any. If a problem occurs during this stage, everything is
204 rewound and no changes are made."
205 (let ((trail (safely-trail safe))
210 (dolist (stream (safely-streams safe))
215 (let ((job (pop trail)))
217 (:shunt (destructuring-bind (tag new file) job
218 (declare (ignore tag))
219 (push `(:rmtmp ,new) revert)
220 (if (probe-file file)
221 (let ((old (safe-copy file "old")))
222 (push `(:rmtmp ,old) cleanup)
223 (push `(:revert ,old ,file) revert))
224 (push `(:rmtmp ,file) revert))
226 (:delete (destructuring-bind (tag file) job
227 (declare (ignore tag))
228 (let ((old (safe-copy file "delete")))
229 (push `(:revert ,old ,file) revert)
230 (push `(:rmtmp ,old) cleanup)
231 (delete-file file)))))))
233 (safely-unwind trail)
234 (safely-unwind revert)
235 (safely-unwind cleanup)
236 (safely-reset safe))))
238 (defmacro safely ((safe &key) &body body)
239 "Do stuff within the BODY safely. If BODY completes without errors, the
240 SAFE is committed; otherwise it's bailed."
241 `(let ((,safe (make-safely)))
245 (safely-commit ,safe)
248 (safely-bail ,safe)))))
250 (defmacro safely-writing ((stream file &rest open-args) &body body)
251 "Simple macro for writing a single file safely. STREAM is opened onto a
252 temporary file, and if BODY completes, it is renamed to FILE."
255 (let ((,stream (safely-open-output-stream ,safe ,file ,@open-args)))
258 ;;;----- That's all, folks --------------------------------------------------