plan.lisp 28.8 KB
Newer Older
1
2
3
;;;; -------------------------------------------------------------------------
;;;; Plan

4
(uiop/package:define-package :asdf/plan
5
6
  ;; asdf/action below is needed for required-components, traverse-action and traverse-sub-actions
  ;; that used to live there before 3.2.0.
7
  (:recycle :asdf/plan :asdf)
8
  (:use :uiop/common-lisp :uiop :asdf/upgrade
9
   :asdf/component :asdf/operation :asdf/system
10
   :asdf/cache :asdf/find-system :asdf/find-component
11
   :asdf/operation :asdf/action :asdf/lisp-action)
12
  (:export
13
   #:component-operation-time
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
14
   #:plan #:plan-traversal #:sequential-plan #:*default-plan-class*
15
16
   #:planned-action-status #:plan-action-status #:action-already-done-p
   #:circular-dependency #:circular-dependency-actions
17
   #:needed-in-image-p
18
   #:action-index #:action-planned-p #:action-valid-p
19
   #:plan-record-dependency
20
   #:normalize-forced-systems #:action-forced-p #:action-forced-not-p
21
   #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
22
   #:compute-action-stamp #:traverse-action
23
   #:circular-dependency #:circular-dependency-actions
24
   #:call-while-visiting-action #:while-visiting-action
25
   #:make-plan #:plan-actions #:perform-plan #:plan-operates-on-p
26
27
   #:planned-p #:index #:forced #:forced-not #:total-action-count
   #:planned-action-count #:planned-output-action-count #:visited-actions
28
   #:visiting-action-set #:visiting-action-list #:plan-actions-r
29
   #:required-components #:filtered-sequential-plan
30
   #:plan-system
31
32
   #:plan-action-filter #:plan-component-type #:plan-keep-operation #:plan-keep-component
   #:traverse-actions #:traverse-sub-actions))
33
(in-package :asdf/plan)
34

35
;;;; Generic plan traversal class
36
(with-upgradability ()
37
38
  (defclass plan () ()
    (:documentation "Base class for a plan based on which ASDF can build a system"))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
39
  (defclass plan-traversal (plan)
40
41
    (;; The system for which the plan is computed
     (system :initform nil :initarg :system :accessor plan-system)
42
     ;; Table of systems specified via :force arguments
43
     (forced :initform nil :initarg :force :accessor plan-forced)
44
     ;; Table of systems specified via :force-not argument (and/or immutable)
45
     (forced-not :initform nil :initarg :force-not :accessor plan-forced-not)
46
     ;; Counts of total actions in plan
47
     (total-action-count :initform 0 :accessor plan-total-action-count)
48
     ;; Count of actions that need to be performed
49
     (planned-action-count :initform 0 :accessor plan-planned-action-count)
50
     ;; Count of actions that need to be performed that have a non-empty list of output-files.
51
     (planned-output-action-count :initform 0 :accessor plan-planned-output-action-count)
52
     ;; Table that to actions already visited while walking the dependencies associates status
53
     (visited-actions :initform (make-hash-table :test 'equal) :accessor plan-visited-actions)
54
55
56
57
58
     ;; Actions that depend on those being currently walked through, to detect circularities
     (visiting-action-set ;; as a set
      :initform (make-hash-table :test 'equal) :accessor plan-visiting-action-set)
     (visiting-action-list :initform () :accessor plan-visiting-action-list)) ;; as a list
    (:documentation "Base class for plans that simply traverse dependencies")))
59
60


61
;;;; Planned action status
62
63
64
(with-upgradability ()
  (defgeneric plan-action-status (plan operation component)
    (:documentation "Returns the ACTION-STATUS associated to
65
66
the action of OPERATION on COMPONENT in the PLAN"))

67
68
  (defgeneric (setf plan-action-status) (new-status plan operation component)
    (:documentation "Sets the ACTION-STATUS associated to
69
70
the action of OPERATION on COMPONENT in the PLAN"))

71
72
73
74
75
76
77
78
79
80
81
82
83
84
  (defclass planned-action-status (action-status)
    ((planned-p
      :initarg :planned-p :reader action-planned-p
      :documentation "a boolean, true iff the action was included in the plan.")
     (index
      :initarg :index :reader action-index
      :documentation "an integer, counting all traversed actions in traversal order."))
    (:documentation "Status of an action in a plan"))

  (defmethod print-object ((status planned-action-status) stream)
    (print-unreadable-object (status stream :type t :identity nil)
      (with-slots (stamp done-p planned-p index) status
        (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p :planned-p planned-p :index index))))

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
85
86
  (defmethod action-planned-p ((action-status t))
    t) ; default method for non planned-action-status objects
87
88

  (defun action-already-done-p (plan operation component)
89
    "According to this plan, is this action already done and up to date?"
90
91
92
93
94
95
96
    (action-done-p (plan-action-status plan operation component)))

  (defmethod plan-action-status ((plan null) (o operation) (c component))
    (multiple-value-bind (stamp done-p) (component-operation-time o c)
      (make-instance 'action-status :stamp stamp :done-p done-p)))

  (defmethod (setf plan-action-status) (new-status (plan null) (o operation) (c component))
97
    (let ((times (component-operation-times c)))
98
      (if (action-done-p new-status)
99
100
          (remhash o times)
          (setf (gethash o times) (action-stamp new-status))))
101
    new-status))
102
103
104


;;;; forcing
105
(with-upgradability ()
106
107
108
109
110
111
112
113
114
115
116
117
118
  (defgeneric action-forced-p (plan operation component)
    (:documentation "Is this action forced to happen in this plan?"))
  (defgeneric action-forced-not-p (plan operation component)
    (:documentation "Is this action forced to not happen in this plan?
Takes precedence over action-forced-p."))

  (defun normalize-forced-systems (force system)
    "Given a SYSTEM on which operate is called and the specified FORCE argument,
extract a hash-set of systems that are forced, or a predicate on system names,
or NIL if none are forced, or :ALL if all are."
    (etypecase force
      ((or (member nil :all) hash-table function) force)
      (cons (list-to-hash-set (mapcar #'coerce-name force)))
119
120
      ((eql t) (when system (list-to-hash-set (list (coerce-name system)))))))

121
122
123
124
  (defun normalize-forced-not-systems (force-not system)
    "Given a SYSTEM on which operate is called, the specified FORCE-NOT argument,
and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not,
or predicate on system names, or NIL if none are forced, or :ALL if all are."
125
    (let ((requested
126
127
128
            (etypecase force-not
              ((or (member nil :all) hash-table function) force-not)
              (cons (list-to-hash-set (mapcar #'coerce-name force-not)))
129
130
              ((eql t) (if system (let ((name (coerce-name system)))
                                    #'(lambda (x) (not (equal x name))))
131
                           :all)))))
132
      (if (and *immutable-systems* requested)
133
134
          #'(lambda (x) (or (call-function requested x)
                            (call-function *immutable-systems* x)))
135
136
          (or *immutable-systems* requested))))

137
  ;; TODO: shouldn't we be looking up the primary system name, rather than the system name?
138
  (defun action-override-p (plan operation component override-accessor)
139
140
    "Given a plan, an action, and a function that given the plan accesses a set of overrides
(i.e. force or force-not), see if the override applies to the current action."
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
141
    (declare (ignore operation))
142
143
    (call-function (funcall override-accessor plan)
                   (coerce-name (component-system (find-component () component)))))
144
145
146
147
148
149

  (defmethod action-forced-p (plan operation component)
    (and
     ;; Did the user ask us to re-perform the action?
     (action-override-p plan operation component 'plan-forced)
     ;; You really can't force a builtin system and :all doesn't apply to it,
150
     ;; except if it's the specifically the system currently being built.
151
152
153
154
155
     (not (let ((system (component-system component)))
            (and (builtin-system-p system)
                 (not (eq system (plan-system plan))))))))

  (defmethod action-forced-not-p (plan operation component)
156
157
158
    ;; Did the user ask us to not re-perform the action?
    ;; NB: force-not takes precedence over force, as it should
    (action-override-p plan operation component 'plan-forced-not))
159

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
160
  (defmethod action-forced-p ((plan null) (operation operation) (component component))
161
162
    nil)

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
163
  (defmethod action-forced-not-p ((plan null) (operation operation) (component component))
164
    nil))
165
166
167


;;;; action-valid-p
168
169
170
(with-upgradability ()
  (defgeneric action-valid-p (plan operation component)
    (:documentation "Is this action valid to include amongst dependencies?"))
171
  ;; :if-feature will invalidate actions on components for which the features don't apply.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
172
  (defmethod action-valid-p ((plan t) (o operation) (c component))
173
    (if-let (it (component-if-feature c)) (featurep it) t))
174
  ;; If either the operation or component was resolved to nil, the action is invalid.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
175
176
  (defmethod action-valid-p ((plan t) (o null) (c t)) nil)
  (defmethod action-valid-p ((plan t) (o t) (c null)) nil)
177
178
  ;; If the plan is null, i.e., we're looking at reality,
  ;; then any action with actual operation and component objects is valid.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
179
  (defmethod action-valid-p ((plan null) (o operation) (c component)) t))
180
181

;;;; Is the action needed in this image?
182
183
(with-upgradability ()
  (defgeneric needed-in-image-p (operation component)
184
185
    (:documentation "Is the action of OPERATION on COMPONENT needed in the current image
to be meaningful, or could it just as well have been done in another Lisp image?"))
186

187
188
189
190
191
192
  (defmethod needed-in-image-p ((o operation) (c component))
    ;; We presume that actions that modify the filesystem don't need be run
    ;; in the current image if they have already been done in another,
    ;; and can be run in another process (e.g. a fork),
    ;; whereas those that don't are meant to side-effect the current image and can't.
    (not (output-files o c))))
193
194
195


;;;; Visiting dependencies of an action and computing action stamps
196
(with-upgradability ()
197
  (defun* (map-direct-dependencies) (plan operation component fun)
198
    "Call FUN on all the valid dependencies of the given action in the given plan"
199
    (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component)
200
201
202
203
           :for dep-o = (find-operation operation dep-o-spec)
           :when dep-o
           :do (loop :for dep-c-spec :in dep-c-specs
                     :for dep-c = (and dep-c-spec (resolve-dependency-spec component dep-c-spec))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
204
                     :when (and dep-c (action-valid-p plan dep-o dep-c))
205
                       :do (funcall fun dep-o dep-c))))
206

207
  (defun* (reduce-direct-dependencies) (plan operation component combinator seed)
208
209
210
    "Reduce the direct dependencies to a value computed by iteratively calling COMBINATOR
for each dependency action on the dependency's operation and component and an accumulator
initialized with SEED."
211
    (map-direct-dependencies
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
212
     plan operation component
213
214
215
216
     #'(lambda (dep-o dep-c)
         (setf seed (funcall combinator dep-o dep-c seed))))
    seed)

217
  (defun* (direct-dependencies) (plan operation component)
218
    "Compute a list of the direct dependencies of the action within the plan"
219
    (reverse (reduce-direct-dependencies plan operation component #'acons nil)))
220

221
222
223
224
  ;; In a distant future, get-file-stamp, component-operation-time and latest-stamp
  ;; shall also be parametrized by the plan, or by a second model object,
  ;; so they need not refer to the state of the filesystem,
  ;; and the stamps could be cryptographic checksums rather than timestamps.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
225
  ;; Such a change remarkably would only affect COMPUTE-ACTION-STAMP.
226
227

  (defmethod compute-action-stamp (plan (o operation) (c component) &key just-done)
228
229
230
231
232
233
234
235
236
    ;; Given an action, figure out at what time in the past it has been done,
    ;; or if it has just been done, return the time that it has.
    ;; Returns two values:
    ;; 1- the TIMESTAMP of the action if it has already been done and is up to date,
    ;;   or T is either hasn't been done or is out of date.
    ;; 2- the DONE-IN-IMAGE-P boolean flag that is T if the action has already been done
    ;;   in the current image, or NIL if it hasn't.
    ;; Note that if e.g. LOAD-OP only depends on up-to-date files, but
    ;; hasn't been done in the current image yet, then it can have a non-T timestamp,
237
238
    ;; yet a NIL done-in-image-p flag: we can predict what timestamp it will have once loaded,
    ;; i.e. that of the input-files.
239
240
241
    (nest
     (block ())
     (let ((dep-stamp ; collect timestamp from dependencies (or T if forced or out-of-date)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
242
243
244
245
246
247
248
             (reduce-direct-dependencies
              plan o c
              #'(lambda (o c stamp)
                  (if-let (it (plan-action-status plan o c))
                    (latest-stamp stamp (action-stamp it))
                    t))
              nil)))
249
250
251
252
253
254
255
256
257
       ;; out-of-date dependency: don't bother expensively querying the filesystem
       (when (and (eq dep-stamp t) (not just-done)) (return (values t nil))))
     ;; collect timestamps from inputs, and exit early if any is missing
     (let* ((in-files (input-files o c))
            (in-stamps (mapcar #'get-file-stamp in-files))
            (missing-in (loop :for f :in in-files :for s :in in-stamps :unless s :collect f))
            (latest-in (stamps-latest (cons dep-stamp in-stamps))))
       (when (and missing-in (not just-done)) (return (values t nil))))
     ;; collect timestamps from outputs, and exit early if any is missing
258
     (let* ((out-files (remove-if 'null (output-files o c)))
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
            (out-stamps (mapcar (if just-done 'register-file-stamp 'get-file-stamp) out-files))
            (missing-out (loop :for f :in out-files :for s :in out-stamps :unless s :collect f))
            (earliest-out (stamps-earliest out-stamps)))
       (when (and missing-out (not just-done)) (return (values t nil))))
     (let* (;; There are three kinds of actions:
            (out-op (and out-files t)) ; those that create files on the filesystem
            ;;(image-op (and in-files (null out-files))) ; those that load stuff into the image
            ;;(null-op (and (null out-files) (null in-files))) ; placeholders that do nothing
            ;; When was the thing last actually done? (Now, or ask.)
            (op-time (or just-done (component-operation-time o c)))
            ;; Time stamps from the files at hand, and whether any is missing
            (all-present (not (or missing-in missing-out)))
            ;; Has any input changed since we last generated the files?
            (up-to-date-p (stamp<= latest-in earliest-out))
            ;; If everything is up to date, the latest of inputs and outputs is our stamp
            (done-stamp (stamps-latest (cons latest-in out-stamps))))
       ;; Warn if some files are missing:
       ;; either our model is wrong or some other process is messing with our files.
       (when (and just-done (not all-present))
         (warn "~A completed without ~:[~*~;~*its input file~:p~2:*~{ ~S~}~*~]~
                ~:[~; or ~]~:[~*~;~*its output file~:p~2:*~{ ~S~}~*~]"
               (action-description o c)
               missing-in (length missing-in) (and missing-in missing-out)
               missing-out (length missing-out))))
     ;; Note that we use stamp<= instead of stamp< to play nice with generated files.
     ;; Any race condition is intrinsic to the limited timestamp resolution.
     (if (or just-done ;; The done-stamp is valid: if we're just done, or
             ;; if all filesystem effects are up-to-date and there's no invalidating reason.
             (and all-present up-to-date-p (operation-done-p o c) (not (action-forced-p plan o c))))
         (values done-stamp ;; return the hard-earned timestamp
                 (or just-done
                     out-op ;; a file-creating op is done when all files are up to date
                     ;; a image-effecting a placeholder op is done when it was actually run,
                     (and op-time (eql op-time done-stamp)))) ;; with the matching stamp
         ;; done-stamp invalid: return a timestamp in an indefinite future, action not done yet
         (values t nil)))))
295
296


297
298
299
;;;; Generic support for plan-traversal
(with-upgradability ()
  (defmethod initialize-instance :after ((plan plan-traversal)
300
                                         &key force force-not system
301
302
                                         &allow-other-keys)
    (with-slots (forced forced-not) plan
303
304
      (setf forced (normalize-forced-systems force system))
      (setf forced-not (normalize-forced-not-systems force-not system))))
305

306
307
308
309
310
311
  (defgeneric plan-actions (plan)
    (:documentation "Extract from a plan a list of actions to perform in sequence"))
  (defmethod plan-actions ((plan list))
    plan)

  (defmethod (setf plan-action-status) (new-status (p plan-traversal) (o operation) (c component))
312
    (setf (gethash (cons o c) (plan-visited-actions p)) new-status))
313
314
315

  (defmethod plan-action-status ((p plan-traversal) (o operation) (c component))
    (or (and (action-forced-not-p p o c) (plan-action-status nil o c))
316
        (values (gethash (cons o c) (plan-visited-actions p)))))
317

318
319
  (defmethod action-valid-p ((p plan-traversal) (o operation) (s system))
    (and (not (action-forced-not-p p o s)) (call-next-method)))
320

321
322
323
324
325
326
327
328
329
330
331
332
333
334
  (defgeneric plan-record-dependency (plan operation component)
    (:documentation "Record an action as a dependency in the current plan")))


;;;; Detection of circular dependencies
(with-upgradability ()
  (define-condition circular-dependency (system-definition-error)
    ((actions :initarg :actions :reader circular-dependency-actions))
    (:report (lambda (c s)
               (format s (compatfmt "~@<Circular dependency: ~3i~_~S~@:>")
                       (circular-dependency-actions c)))))

  (defgeneric call-while-visiting-action (plan operation component function)
    (:documentation "Detect circular dependencies"))
335
336
337
338

  (defmethod call-while-visiting-action ((plan plan-traversal) operation component fun)
    (with-accessors ((action-set plan-visiting-action-set)
                     (action-list plan-visiting-action-list)) plan
339
      (let ((action (make-action operation component)))
340
341
342
343
344
345
346
347
        (when (gethash action action-set)
          (error 'circular-dependency :actions
                 (member action (reverse action-list) :test 'equal)))
        (setf (gethash action action-set) t)
        (push action action-list)
        (unwind-protect
             (funcall fun)
          (pop action-list)
348
349
350
351
352
          (setf (gethash action action-set) nil)))))

  ;; Syntactic sugar for call-while-visiting-action
  (defmacro while-visiting-action ((p o c) &body body)
    `(call-while-visiting-action ,p ,o ,c #'(lambda () ,@body))))
353
354
355


;;;; Actual traversal: traverse-action
356
357
358
(with-upgradability ()
  (defgeneric traverse-action (plan operation component needed-in-image-p))

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
359
360
361
362
363
364
365
366
  ;; TRAVERSE-ACTION, in the context of a given PLAN object that accumulates dependency data,
  ;; visits the action defined by its OPERATION and COMPONENT arguments,
  ;; and all its transitive dependencies (unless already visited),
  ;; in the context of the action being (or not) NEEDED-IN-IMAGE-P,
  ;; i.e. needs to be done in the current image vs merely have been done in a previous image.
  ;; For actions that are up-to-date, it returns a STAMP identifying the state of the action
  ;; (that's timestamp, but it could be a cryptographic digest in some ASDF extension),
  ;; or T if the action needs to be done again.
367
368
369
370
371
  ;;
  ;; Note that for an XCVB-like plan with one-image-per-file-outputting-action,
  ;; the below method would be insufficient, since it assumes a single image
  ;; to traverse each node at most twice; non-niip actions would be traversed only once,
  ;; but niip nodes could be traversed once per image, i.e. once plus once per non-niip action.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
372

373
374
  (defmethod traverse-action (plan operation component needed-in-image-p)
    (block nil
375
376
      ;; ACTION-VALID-P among other things, handles forcing logic, including FORCE-NOT,
      ;; and IF-FEATURE filtering.
377
      (unless (action-valid-p plan operation component) (return nil))
378
      ;; the following hook is needed by POIU, which tracks a full dependency graph,
379
      ;; instead of just a dependency order as in vanilla ASDF
380
      (plan-record-dependency plan operation component)
381
      ;; needed in image distinguishes b/w things that must happen in the
382
383
384
      ;; current image and those things that simply need to have been done in a previous one.
      (let* ((aniip (needed-in-image-p operation component)) ; action-specific needed-in-image
             ;; effective niip: meaningful for the action and required by the plan as traversed
385
             (eniip (and aniip needed-in-image-p))
386
             ;; status: have we traversed that action previously, and if so what was its status?
387
388
             (status (plan-action-status plan operation component)))
        (when (and status (or (action-done-p status) (action-planned-p status) (not eniip)))
389
390
          (return (action-stamp status))) ; Already visited with sufficient need-in-image level!
        (labels ((visit-action (niip) ; We may visit the action twice, once with niip NIL, then T
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
391
392
                   (map-direct-dependencies ; recursively traverse dependencies
                    plan operation component #'(lambda (o c) (traverse-action plan o c niip)))
393
394
                   (multiple-value-bind (stamp done-p) ; AFTER dependencies have been traversed,
                       (compute-action-stamp plan operation component) ; compute action stamp
395
                     (let ((add-to-plan-p (or (eql stamp t) (and niip (not done-p)))))
396
397
398
                       (cond ; it needs be done if it's out of date or needed in image but absent
                         ((and add-to-plan-p (not niip)) ; if we need to do it,
                          (visit-action t)) ; then we need to do it *in the (current) image*!
399
                         (t
400
                          (setf (plan-action-status plan operation component) ; update status:
401
402
                                (make-instance
                                 'planned-action-status
403
404
405
406
407
408
                                 :stamp stamp ; computed stamp
                                 :done-p (and done-p (not add-to-plan-p)) ; done *and* up-to-date?
                                 :planned-p add-to-plan-p ; included in list of things to be done?
                                 :index (if status ; index of action amongst all nodes in traversal
                                            (action-index status) ;; if already visited, keep index
                                            (incf (plan-total-action-count plan))))) ; else new index
409
410
                          (when (and done-p (not add-to-plan-p))
                            (setf (component-operation-time operation component) stamp))
411
412
413
414
415
                          (when add-to-plan-p ; if it needs to be added to the plan,
                            (incf (plan-planned-action-count plan)) ; count it
                            (unless aniip ; if it's output-producing,
                              (incf (plan-planned-output-action-count plan)))) ; count it
                          stamp)))))) ; return the stamp
416
          (while-visiting-action (plan operation component) ; maintain context, handle circularity.
417
            (visit-action eniip))))))) ; visit the action
418
419
420


;;;; Sequential plans (the default)
421
422
(with-upgradability ()
  (defclass sequential-plan (plan-traversal)
423
424
    ((actions-r :initform nil :accessor plan-actions-r))
    (:documentation "Simplest, default plan class, accumulating a sequence of actions"))
425

426
427
  (defmethod plan-actions ((plan sequential-plan))
    (reverse (plan-actions-r plan)))
428

429
  ;; No need to record a dependency to build a full graph, just accumulate nodes in order.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
430
  (defmethod plan-record-dependency ((plan sequential-plan) (o operation) (c component))
431
    (values))
432

433
434
435
  (defmethod (setf plan-action-status) :after
      (new-status (p sequential-plan) (o operation) (c component))
    (when (action-planned-p new-status)
436
      (push (make-action o c) (plan-actions-r p)))))
437

438

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
439
;;;; High-level interface: traverse, perform-plan, plan-operates-on-p
440
(with-upgradability ()
441
  (defgeneric make-plan (plan-class operation component &key &allow-other-keys)
442
    (:documentation "Generate and return a plan for performing OPERATION on COMPONENT."))
443
444
  (define-convenience-action-methods make-plan (plan-class operation component &key))

445
446
447
448
  (defgeneric perform-plan (plan &key)
    (:documentation "Actually perform a plan and build the requested actions"))
  (defgeneric plan-operates-on-p (plan component)
    (:documentation "Does this PLAN include any operation on given COMPONENT?"))
449

450
451
  (defvar *default-plan-class* 'sequential-plan
    "The default plan class to use when building with ASDF")
452

453
  (defmethod make-plan (plan-class (o operation) (c component) &rest keys &key &allow-other-keys)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
454
    (let ((plan (apply 'make-instance (or plan-class *default-plan-class*)
455
                       :system (component-system c) keys)))
456
      (traverse-action plan o c t)
457
      plan))
458

459
  (defmethod perform-plan :around ((plan t) &key)
460
    #+xcl (declare (ignorable plan))
461
462
463
464
    (let ((*package* *package*)
          (*readtable* *readtable*))
      (with-compilation-unit () ;; backward-compatibility.
        (call-next-method))))   ;; Going forward, see deferred-warning support in lisp-build.
465

466
467
468
  (defmethod perform-plan ((plan t) &rest keys &key &allow-other-keys)
    (apply 'perform-plan (plan-actions plan) keys))

469
  (defmethod perform-plan ((steps list) &key force &allow-other-keys)
470
471
472
    (loop* :for action :in steps
           :as o = (action-operation action)
           :as c = (action-component action)
473
474
           :when (or force (not (nth-value 1 (compute-action-stamp nil o c))))
           :do (perform-with-restarts o c)))
475

476
477
478
  (defmethod plan-operates-on-p ((plan plan-traversal) (component-path list))
    (plan-operates-on-p (plan-actions plan) component-path))

479
  (defmethod plan-operates-on-p ((plan list) (component-path list))
480
    (find component-path (mapcar 'action-component plan)
481
          :test 'equal :key 'component-find-path)))
482

483

484
;;;; Incidental traversals
485
486
487

;;; Making a FILTERED-SEQUENTIAL-PLAN can be used to, e.g., all of the source
;;; files required by a bundling operation.
488
489
490
491
492
(with-upgradability ()
  (defclass filtered-sequential-plan (sequential-plan)
    ((action-filter :initform t :initarg :action-filter :reader plan-action-filter)
     (component-type :initform t :initarg :component-type :reader plan-component-type)
     (keep-operation :initform t :initarg :keep-operation :reader plan-keep-operation)
493
494
     (keep-component :initform t :initarg :keep-component :reader plan-keep-component))
    (:documentation "A variant of SEQUENTIAL-PLAN that only records a subset of actions."))
495
496

  (defmethod initialize-instance :after ((plan filtered-sequential-plan)
497
                                         &key force force-not
498
                                         other-systems)
499
    (declare (ignore force force-not))
500
501
502
    ;; Ignore force and force-not, rely on other-systems:
    ;; force traversal of what we're interested in, i.e. current system or also others;
    ;; force-not traversal of what we're not interested in, i.e. other systems unless other-systems.
503
    (with-slots (forced forced-not action-filter system) plan
504
505
      (setf forced (normalize-forced-systems (if other-systems :all t) system))
      (setf forced-not (normalize-forced-not-systems (if other-systems nil t) system))
506
507
508
509
510
511
512
      (setf action-filter (ensure-function action-filter))))

  (defmethod action-valid-p ((plan filtered-sequential-plan) o c)
    (and (funcall (plan-action-filter plan) o c)
         (typep c (plan-component-type plan))
         (call-next-method)))

513
  (defun* (traverse-actions) (actions &rest keys &key plan-class &allow-other-keys)
514
    "Given a list of actions, build a plan with these actions as roots."
515
    (let ((plan (apply 'make-instance (or plan-class 'filtered-sequential-plan) keys)))
516
517
518
519
      (loop* :for action :in actions
             :as o = (action-operation action)
             :as c = (action-component action)
             :do (traverse-action plan o c t))
520
      plan))
521

522
  (defgeneric traverse-sub-actions (operation component &key &allow-other-keys))
523
  (define-convenience-action-methods traverse-sub-actions (operation component &key))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
524
525
526
  (defmethod traverse-sub-actions ((operation operation) (component component)
                                   &rest keys &key &allow-other-keys)
    (apply 'traverse-actions (direct-dependencies t operation component)
527
528
529
530
           :system (component-system component) keys))

  (defmethod plan-actions ((plan filtered-sequential-plan))
    (with-slots (keep-operation keep-component) plan
531
532
533
      (loop* :for action :in (call-next-method)
             :as o = (action-operation action)
             :as c = (action-component action)
534
             :when (and (typep o keep-operation) (typep c keep-component))
535
             :collect (make-action o c))))
536

537
  (defun* (required-components) (system &rest keys &key (goal-operation 'load-op) &allow-other-keys)
538
539
    "Given a SYSTEM and a GOAL-OPERATION (default LOAD-OP), traverse the dependencies and
return a list of the components involved in building the desired action."
540
    (remove-duplicates
541
542
543
544
     (mapcar 'action-component
             (plan-actions
              (apply 'traverse-sub-actions goal-operation system
                     (remove-plist-key :goal-operation keys))))
545
     :from-end t)))
546