action.lisp 23.3 KB
Newer Older
1
2
3
;;;; -------------------------------------------------------------------------
;;;; Actions

4
(uiop/package:define-package :asdf/action
5
  (:nicknames :asdf-action)
6
  (:recycle :asdf/action :asdf)
7
  (:use :uiop/common-lisp :uiop :asdf/upgrade
8
   :asdf/component :asdf/system #:asdf/session :asdf/find-system :asdf/find-component :asdf/operation)
9
  (:import-from :asdf/operation #:check-operation-constructor)
10
  #-clisp (:unintern #:required-components #:traverse-action #:traverse-sub-actions)
11
  (:export
12
   #:action #:define-convenience-action-methods
13
   #:action-description
14
   #:downward-operation #:upward-operation #:sideway-operation #:selfward-operation #:non-propagating-operation
15
   #:component-depends-on
16
17
   #:input-files #:output-files #:output-file #:operation-done-p
   #:action-status #:action-stamp #:action-done-p
18
   #:action-operation #:action-component #:make-action
19
   #:component-operation-time #:mark-operation-done #:compute-action-stamp
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
20
   #:perform #:perform-with-restarts #:retry #:accept
21
   #:action-path #:find-action #:stamp #:done-p
22
   #:operation-definition-warning #:operation-definition-error ;; condition
23
   ))
24
25
(in-package :asdf/action)

26
(eval-when (#-lispworks :compile-toplevel :load-toplevel :execute) ;; LispWorks issues spurious warning
27
28
29
30
31

  (deftype action ()
    "A pair of operation and component uniquely identifies a node in the dependency graph
of steps to be performed while building a system."
    '(cons operation component))
32
33

  (deftype operation-designator ()
34
35
    "An operation designates itself. NIL designates a context-dependent current operation,
and a class-name or class designates the canonical instance of the designated class."
36
    '(or operation null symbol class)))
37

38
39
40
41
42
43
44
45
46
;;; these are pseudo accessors -- let us abstract away the CONS cell representation of plan
;;; actions.
(with-upgradability ()
  (defun make-action (operation component)
    (cons operation component))
  (defun action-operation (action)
    (car action))
  (defun action-component (action)
    (cdr action)))
47

48
;;;; Reified representation for storage or debugging. Note: an action is identified by its class.
49
50
(with-upgradability ()
  (defun action-path (action)
51
    "A readable data structure that identifies the action."
52
53
54
    (let ((o (action-operation action))
          (c (action-component action)))
      (cons (type-of o) (component-find-path c))))
55
  (defun find-action (path)
56
    "Reconstitute an action from its action-path"
57
    (destructuring-bind (o . c) path (make-action (make-operation o) (find-component () c)))))
58
59

;;;; Convenience methods
60
(with-upgradability ()
61
62
63
64
65
66
67
68
  ;; A macro that defines convenience methods for a generic function (gf) that
  ;; dispatches on operation and component.  The convenience methods allow users
  ;; to call the gf with operation and/or component designators, that the
  ;; methods will resolve into actual operation and component objects, so that
  ;; the users can interact using readable designators, but developers only have
  ;; to write methods that handle operation and component objects.
  ;; FUNCTION is the generic function name
  ;; FORMALS is its list of arguments, which must include OPERATION and COMPONENT.
69
70
  ;; IF-NO-OPERATION is a form (defaults to NIL) describing what to do if no operation is found.
  ;; IF-NO-COMPONENT is a form (defaults to NIL) describing what to do if no component is found.
71
  (defmacro define-convenience-action-methods
72
      (function formals &key if-no-operation if-no-component)
73
74
    (let* ((rest (gensym "REST"))
           (found (gensym "FOUND"))
75
76
77
           (keyp (equal (last formals) '(&key)))
           (formals-no-key (if keyp (butlast formals) formals))
           (len (length formals-no-key))
78
79
80
81
82
83
           (operation 'operation)
           (component 'component)
           (opix (position operation formals))
           (coix (position component formals))
           (prefix (subseq formals 0 opix))
           (suffix (subseq formals (1+ coix) len))
84
           (more-args (when keyp `(&rest ,rest &key &allow-other-keys))))
85
      (assert (and (integerp opix) (integerp coix) (= coix (1+ opix))))
86
87
      (flet ((next-method (o c)
               (if keyp
88
89
                   `(apply ',function ,@prefix ,o ,c ,@suffix ,rest)
                   `(,function ,@prefix ,o ,c ,@suffix))))
90
        `(progn
91
           (defmethod ,function (,@prefix (,operation string) ,component ,@suffix ,@more-args)
92
             (declare (notinline ,function))
93
94
95
             (let ((,component (find-component () ,component))) ;; do it first, for defsystem-depends-on
               ,(next-method `(safe-read-from-string ,operation :package :asdf/interface) component)))
           (defmethod ,function (,@prefix (,operation symbol) ,component ,@suffix ,@more-args)
96
             (declare (notinline ,function))
97
98
             (if ,operation
                 ,(next-method
99
                   `(make-operation ,operation)
100
101
                   `(or (find-component () ,component) ,if-no-component))
                 ,if-no-operation))
102
           (defmethod ,function (,@prefix (,operation operation) ,component ,@suffix ,@more-args)
103
             (declare (notinline ,function))
104
105
             (if (typep ,component 'component)
                 (error "No defined method for ~S on ~/asdf-action:format-action/"
106
                        ',function (make-action ,operation ,component))
107
108
109
                 (if-let (,found (find-component () ,component))
                    ,(next-method operation found)
                    ,if-no-component))))))))
110

111
112

;;;; self-description
113
114
115
(with-upgradability ()
  (defgeneric action-description (operation component)
    (:documentation "returns a phrase that describes performing this operation
116
117
on this component, e.g. \"loading /a/b/c\".
You can put together sentences using this phrase."))
118
119
  (defmethod action-description (operation component)
    (format nil (compatfmt "~@<~A on ~A~@:>")
120
            operation component))
121

122
  (defun format-action (stream action &optional colon-p at-sign-p)
123
124
    "FORMAT helper to display an action's action-description.
Use it in FORMAT control strings as ~/asdf-action:format-action/"
125
126
127
    (assert (null colon-p)) (assert (null at-sign-p))
    (destructuring-bind (operation . component) action
      (princ (action-description operation component) stream))))
128
129
130


;;;; Dependencies
131
(with-upgradability ()
132
  (defgeneric component-depends-on (operation component) ;; ASDF4: rename to component-dependencies
133
134
    (:documentation
     "Returns a list of dependencies needed by the component to perform
135
136
    the operation.  A dependency has one of the following forms:

137
138
139
140
141
      (<operation> <component>*), where <operation> is an operation designator
        with respect to FIND-OPERATION in the context of the OPERATION argument,
        and each <component> is a component designator with respect to
        FIND-COMPONENT in the context of the COMPONENT argument,
        and means that the component depends on
142
143
144
145
        <operation> having been performed on each <component>;

        [Note: an <operation> is an operation designator -- it can be either an
        operation name or an operation object.  Similarly, a <component> may be
146
147
        a component name or a component object.  Also note that, the degenerate
        case of (<operation>) is a no-op.]
148

149
    Methods specialized on subclasses of existing component types
150
    should usually append the results of CALL-NEXT-METHOD to the list."))
151
  (define-convenience-action-methods component-depends-on (operation component))
152
153
154

  (defmethod component-depends-on :around ((o operation) (c component))
    (do-asdf-cache `(component-depends-on ,o ,c)
155
      (call-next-method))))
156
157


158
159
;;;; upward-operation, downward-operation, sideway-operation, selfward-operation
;; These together handle actions that propagate along the component hierarchy or operation universe.
160
161
162
(with-upgradability ()
  (defclass downward-operation (operation)
    ((downward-operation
163
      :initform nil :reader downward-operation
164
      :type operation-designator :allocation :class))
165
166
167
168
169
170
    (:documentation "A DOWNWARD-OPERATION's dependencies propagate down the component hierarchy.
I.e., if O is a DOWNWARD-OPERATION and its DOWNWARD-OPERATION slot designates operation D, then
the action (O . M) of O on module M will depends on each of (D . C) for each child C of module M.
The default value for slot DOWNWARD-OPERATION is NIL, which designates the operation O itself.
E.g. in order for a MODULE to be loaded with LOAD-OP (resp. compiled with COMPILE-OP), all the
children of the MODULE must have been loaded with LOAD-OP (resp. compiled with COMPILE-OP."))
171
172
  (defun downward-operation-depends-on (o c)
    `((,(or (downward-operation o) o) ,@(component-children c))))
173
  (defmethod component-depends-on ((o downward-operation) (c parent-component))
174
    `(,@(downward-operation-depends-on o c) ,@(call-next-method)))
175

176
177
  (defclass upward-operation (operation)
    ((upward-operation
178
      :initform nil :reader upward-operation
179
      :type operation-designator :allocation :class))
180
181
182
183
184
185
    (:documentation "An UPWARD-OPERATION has dependencies that propagate up the component hierarchy.
I.e., if O is an instance of UPWARD-OPERATION, and its UPWARD-OPERATION slot designates operation U,
then the action (O . C) of O on a component C that has the parent P will depends on (U . P).
The default value for slot UPWARD-OPERATION is NIL, which designates the operation O itself.
E.g. in order for a COMPONENT to be prepared for loading or compiling with PREPARE-OP, its PARENT
must first be prepared for loading or compiling with PREPARE-OP."))
186
187
  ;; For backward-compatibility reasons, a system inherits from module and is a child-component
  ;; so we must guard against this case. ASDF4: remove that.
188
189
  (defun upward-operation-depends-on (o c)
    (if-let (p (component-parent c)) `((,(or (upward-operation o) o) ,p))))
190
  (defmethod component-depends-on ((o upward-operation) (c child-component))
191
    `(,@(upward-operation-depends-on o c) ,@(call-next-method)))
192

193
194
  (defclass sideway-operation (operation)
    ((sideway-operation
195
      :initform nil :reader sideway-operation
196
      :type operation-designator :allocation :class))
197
198
199
200
201
202
    (:documentation "A SIDEWAY-OPERATION has dependencies that propagate \"sideway\" to siblings
that a component depends on. I.e. if O is a SIDEWAY-OPERATION, and its SIDEWAY-OPERATION slot
designates operation S (where NIL designates O itself), then the action (O . C) of O on component C
depends on each of (S . D) where D is a declared dependency of C.
E.g. in order for a COMPONENT to be prepared for loading or compiling with PREPARE-OP,
each of its declared dependencies must first be loaded as by LOAD-OP."))
203
  (defun sideway-operation-depends-on (o c)
204
    `((,(or (sideway-operation o) o) ,@(component-sideway-dependencies c))))
205
206
  (defmethod component-depends-on ((o sideway-operation) (c component))
    `(,@(sideway-operation-depends-on o c) ,@(call-next-method)))
207

208
209
  (defclass selfward-operation (operation)
    ((selfward-operation
210
      ;; NB: no :initform -- if an operation depends on others, it must explicitly specify which
211
      :type (or operation-designator list) :reader selfward-operation :allocation :class))
212
    (:documentation "A SELFWARD-OPERATION depends on another operation on the same component.
213
214
I.e., if O is a SELFWARD-OPERATION, and its SELFWARD-OPERATION designates a list of operations L,
then the action (O . C) of O on component C depends on each (S . C) for S in L.
215
E.g. before a component may be loaded by LOAD-OP, it must have been compiled by COMPILE-OP.
216
217
A operation-designator designates a singleton list of the designated operation;
a list of operation-designators designates the list of designated operations;
218
219
220
NIL is not a valid operation designator in that context.  Note that any dependency
ordering between the operations in a list of SELFWARD-OPERATION should be specified separately
in the respective operation's COMPONENT-DEPENDS-ON methods so that they be scheduled properly."))
221
222
  (defun selfward-operation-depends-on (o c)
    (loop :for op :in (ensure-list (selfward-operation o)) :collect `(,op ,c)))
223
  (defmethod component-depends-on ((o selfward-operation) (c component))
224
    `(,@(selfward-operation-depends-on o c) ,@(call-next-method)))
225
226
227

  (defclass non-propagating-operation (operation)
    ()
228
    (:documentation "A NON-PROPAGATING-OPERATION is an operation that propagates
229
230
231
232
233
234
235
236
no dependencies whatsoever.  It is supplied in order that the programmer be able
to specify that s/he is intentionally specifying an operation which invokes no
dependencies.")))


;;;---------------------------------------------------------------------------
;;; Help programmers catch obsolete OPERATION subclasses
;;;---------------------------------------------------------------------------
237
238
239
240
241
242
243
244
245
246
(with-upgradability ()
  (define-condition operation-definition-warning (simple-warning)
    ()
    (:documentation "Warning condition related to definition of obsolete OPERATION objects."))

  (define-condition operation-definition-error (simple-error)
    ()
    (:documentation "Error condition related to definition of incorrect OPERATION objects."))

  (defmethod initialize-instance :before ((o operation) &key)
247
    (check-operation-constructor)
248
    (unless (typep o '(or downward-operation upward-operation sideway-operation
249
                          selfward-operation non-propagating-operation))
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
      (warn 'operation-definition-warning
            :format-control
            "No dependency propagating scheme specified for operation class ~S.
The class needs to be updated for ASDF 3.1 and specify appropriate propagation mixins."
            :format-arguments (list (type-of o)))))

  (defmethod initialize-instance :before ((o non-propagating-operation) &key)
    (when (typep o '(or downward-operation upward-operation sideway-operation selfward-operation))
      (error 'operation-definition-error
             :format-control
             "Inconsistent class: ~S
  NON-PROPAGATING-OPERATION is incompatible with propagating operation classes as superclasses."
             :format-arguments
             (list (type-of o)))))

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
265
266
  (defun backward-compatible-depends-on (o c)
    "DEPRECATED: all subclasses of OPERATION used in ASDF should inherit from one of
267
268
269
 DOWNWARD-OPERATION UPWARD-OPERATION SIDEWAY-OPERATION SELFWARD-OPERATION NON-PROPAGATING-OPERATION.
 The function BACKWARD-COMPATIBLE-DEPENDS-ON temporarily provides ASDF2 behaviour for those that
 don't. In the future this functionality will be removed, and the default will be no propagation."
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
270
271
272
273
274
    (uiop/version::notify-deprecated-function
     (version-deprecation *asdf-version* :style-warning "3.2")
     'backward-compatible-depends-on)
    `(,@(sideway-operation-depends-on o c)
      ,@(when (typep c 'parent-component) (downward-operation-depends-on o c))))
275

276
277
278
  (defmethod component-depends-on ((o operation) (c component))
    `(;; Normal behavior, to allow user-specified in-order-to dependencies
      ,@(cdr (assoc (type-of o) (component-in-order-to c)))
279
280
281
282
283
        ;; For backward-compatibility with ASDF2, any operation that doesn't specify propagation
        ;; or non-propagation through an appropriate mixin will be downward and sideway.
        ,@(unless (typep o '(or downward-operation upward-operation sideway-operation
                             selfward-operation non-propagating-operation))
            (backward-compatible-depends-on o c))))
284
285
286
287

  (defmethod downward-operation ((o operation)) nil)
  (defmethod sideway-operation ((o operation)) nil))

288
289
290
291

;;;---------------------------------------------------------------------------
;;; End of OPERATION class checking
;;;---------------------------------------------------------------------------
292
293
294


;;;; Inputs, Outputs, and invisible dependencies
295
(with-upgradability ()
296
  (defgeneric output-files (operation component)
297
    (:documentation "Methods for this function return two values: a list of output files
298
299
300
corresponding to this action, and a boolean indicating if they have already been subjected
to relevant output translations and should not be further translated.

301
Methods on PERFORM *must* call this function to determine where their outputs are to be located.
302
303
They may rely on the order of the files to discriminate between outputs.
"))
304
  (defgeneric input-files (operation component)
305
306
    (:documentation "A list of input files corresponding to this action.

307
Methods on PERFORM *must* call this function to determine where their inputs are located.
308
309
They may rely on the order of the files to discriminate between inputs.
"))
310
  (defgeneric operation-done-p (operation component)
311
    (:documentation "Returns a boolean which is NIL if the action must be performed (again)."))
312
313
314
315
316
317
318
  (define-convenience-action-methods output-files (operation component))
  (define-convenience-action-methods input-files (operation component))
  (define-convenience-action-methods operation-done-p (operation component))

  (defmethod operation-done-p ((o operation) (c component))
    t)

319
  ;; Translate output files, unless asked not to. Memoize the result.
320
  (defmethod output-files :around ((operation t) (component t))
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
    (do-asdf-cache `(output-files ,operation ,component)
      (values
       (multiple-value-bind (pathnames fixedp) (call-next-method)
         ;; 1- Make sure we have absolute pathnames
         (let* ((directory (pathname-directory-pathname
                            (component-pathname (find-component () component))))
                (absolute-pathnames
                  (loop
                    :for pathname :in pathnames
                    :collect (ensure-absolute-pathname pathname directory))))
           ;; 2- Translate those pathnames as required
           (if fixedp
               absolute-pathnames
               (mapcar *output-translation-function* absolute-pathnames))))
       t)))
  (defmethod output-files ((o operation) (c component))
    nil)
  (defun output-file (operation component)
    "The unique output file of performing OPERATION on COMPONENT"
    (let ((files (output-files operation component)))
      (assert (length=n-p files 1))
      (first files)))

344
  ;; Memoize input files.
345
346
347
348
  (defmethod input-files :around (operation component)
    (do-asdf-cache `(input-files ,operation ,component)
      (call-next-method)))

349
  ;; By default an action has no input-files.
350
  (defmethod input-files ((o operation) (c component))
351
352
    nil)

353
354
355
356
  ;; An action with a selfward-operation by default gets its input-files from the output-files of
  ;; the actions using selfward-operations it depends on (and the same component),
  ;; or if there are none, on the component-pathname of the component if it's a file
  ;; -- and then on the results of the next-method.
357
358
359
360
361
362
  (defmethod input-files ((o selfward-operation) (c component))
    `(,@(or (loop :for dep-o :in (ensure-list (selfward-operation o))
                  :append (or (output-files dep-o c) (input-files dep-o c)))
            (if-let ((pathname (component-pathname c)))
              (and (file-pathname-p pathname) (list pathname))))
      ,@(call-next-method))))
363
364
365


;;;; Done performing
366
(with-upgradability ()
367
368
369
370
371
  ;; ASDF4: hide it behind plan-action-stamp
  (defgeneric component-operation-time (operation component)
    (:documentation "Return the timestamp for when an action was last performed"))
  (defgeneric (setf component-operation-time) (time operation component)
    (:documentation "Update the timestamp for when an action was last performed"))
372
  (define-convenience-action-methods component-operation-time (operation component))
373

374
375
376
377
378
379
  ;; ASDF4: hide it behind (setf plan-action-stamp)
  (defgeneric mark-operation-done (operation component)
    (:documentation "Mark a action as having been just done.

Updates the action's COMPONENT-OPERATION-TIME to match the COMPUTE-ACTION-STAMP
using the JUST-DONE flag."))
380
381
  (defgeneric compute-action-stamp (plan operation component &key just-done)
    (:documentation "Has this action been successfully done already,
382
and at what known timestamp has it been done at or will it be done at?
383
384
385
386
* PLAN is a plan object modelling future effects of actions,
  or NIL to denote what actually happened.
* OPERATION and COMPONENT denote the action.
Takes keyword JUST-DONE:
387
388
389
* JUST-DONE is a boolean that is true if the action was just successfully performed,
  at which point we want compute the actual stamp and warn if files are missing;
  otherwise we are making plans, anticipating the effects of the action.
390
391
Returns two values:
* a STAMP saying when it was done or will be done,
392
  or T if the action involves files that need to be recomputed.
393
394
395
* a boolean DONE-P that indicates whether the action has actually been done,
  and both its output-files and its in-image side-effects are up to date."))

396
397
398
399
  (defclass action-status ()
    ((stamp
      :initarg :stamp :reader action-stamp
      :documentation "STAMP associated with the ACTION if it has been completed already
400
in some previous image, or T if it needs to be done.")
401
402
403
404
     (done-p
      :initarg :done-p :reader action-done-p
      :documentation "a boolean, true iff the action was already done (before any planned action)."))
    (:documentation "Status of an action"))
405

406
407
408
409
  (defmethod print-object ((status action-status) stream)
    (print-unreadable-object (status stream :type t)
      (with-slots (stamp done-p) status
        (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p))))
410

411
  (defmethod component-operation-time ((o operation) (c component))
412
    (gethash o (component-operation-times c)))
413

414
  (defmethod (setf component-operation-time) (stamp (o operation) (c component))
415
    (setf (gethash o (component-operation-times c)) stamp))
416

417
  (defmethod mark-operation-done ((o operation) (c component))
418
    (setf (component-operation-time o c) (compute-action-stamp nil o c :just-done t))))
419
420
421


;;;; Perform
422
(with-upgradability ()
423
  (defgeneric perform (operation component)
424
    (:documentation "PERFORM an action, consuming its input-files and building its output-files"))
425
426
427
428
429
430
431
432
433
  (define-convenience-action-methods perform (operation component))

  (defmethod perform :before ((o operation) (c component))
    (ensure-all-directories-exist (output-files o c)))
  (defmethod perform :after ((o operation) (c component))
    (mark-operation-done o c))
  (defmethod perform ((o operation) (c parent-component))
    nil)
  (defmethod perform ((o operation) (c source-file))
434
435
436
437
438
    ;; For backward compatibility, don't error on operations that don't specify propagation.
    (when (typep o '(or downward-operation upward-operation sideway-operation
                     selfward-operation non-propagating-operation))
      (sysdef-error
       (compatfmt "~@<Required method ~S not implemented for ~/asdf-action:format-action/~@:>")
439
       'perform (make-action o c))))
440

441
442
443
  ;; The restarts of the perform-with-restarts variant matter in an interactive context.
  ;; The retry strategies of p-w-r itself, and/or the background workers of a multiprocess build
  ;; may call perform directly rather than call p-w-r.
444
  (defgeneric perform-with-restarts (operation component)
445
    (:documentation "PERFORM an action in a context where suitable restarts are in place."))
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
  (defmethod perform-with-restarts (operation component)
    (perform operation component))
  (defmethod perform-with-restarts :around (operation component)
    (loop
      (restart-case
          (return (call-next-method))
        (retry ()
          :report
          (lambda (s)
            (format s (compatfmt "~@<Retry ~A.~@:>")
                    (action-description operation component))))
        (accept ()
          :report
          (lambda (s)
            (format s (compatfmt "~@<Continue, treating ~A as having been successful.~@:>")
                    (action-description operation component)))
          (mark-operation-done operation component)
          (return))))))