usr.bin/dsynth/status.c

   1 /*
   2  * Copyright (c) 2019 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * This code uses concepts and configuration based on 'synth', by
   8  * John R. Marino <draco@marino.st>, which was written in ada.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  * 3. Neither the name of The DragonFly Project nor the names of its
  21  *    contributors may be used to endorse or promote products derived
  22  *    from this software without specific, prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  28  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  32  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  33  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  34  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37 /*
  38  * Figure out what would have to be built [N]ew, [R]ebuild, [U]pgrade
  39  * but do not perform any action.
  40  */
  41 #include "dsynth.h"
  42
  43 static int status_find_leaves(pkg_t *parent, pkg_t *pkg, pkg_t ***build_tailp,
  44                         int *app, int *hasworkp, int level, int first);
  45 static void status_clear_trav(pkg_t *pkg);
  46 static void startstatus(pkg_t **build_listp, pkg_t ***build_tailp);
  47
  48 void
  49 DoStatus(pkg_t *pkgs)
  50 {
  51         pkg_t *build_list = NULL;
  52         pkg_t **build_tail = &build_list;
  53         pkg_t *scan;
  54         int haswork = 1;
  55         int first = 1;
  56
  57         /*
  58          * Count up all the packages, do not include dummy packages.
  59          */
  60         for (scan = pkgs; scan; scan = scan->bnext) {
  61                 if ((scan->flags & PKGF_DUMMY) == 0)
  62                         ++BuildTotal;
  63         }
  64
  65         /*
  66          * Nominal bulk build sequence
  67          */
  68         while (haswork) {
  69                 haswork = 0;
  70                 fflush(stdout);
  71                 for (scan = pkgs; scan; scan = scan->bnext) {
  72                         ddprintf(0, "SCANLEAVES %08x %s\n",
  73                                  scan->flags, scan->portdir);
  74                         scan->flags |= PKGF_BUILDLOOP;
  75                         /*
  76                          * NOTE: We must still find dependencies if PACKAGED
  77                          *       to fill in the gaps, as some of them may
  78                          *       need to be rebuilt.
  79                          */
  80                         if (scan->flags & (PKGF_SUCCESS | PKGF_FAILURE |
  81                                            PKGF_ERROR | PKGF_NOBUILD)) {
  82 #if 0
  83                                 ddprintf(0, "%s: already built\n",
  84                                          scan->portdir);
  85 #endif
  86                         } else {
  87                                 int ap = 0;
  88                                 status_find_leaves(NULL, scan, &build_tail,
  89                                                   &ap, &haswork, 0, first);
  90                                 ddprintf(0, "TOPLEVEL %s %08x\n",
  91                                          scan->portdir, ap);
  92                         }
  93                         scan->flags &= ~PKGF_BUILDLOOP;
  94                         status_clear_trav(scan);
  95                 }
  96                 first = 0;
  97                 fflush(stdout);
  98                 if (haswork == 0)
  99                         break;
 100                 startstatus(&build_list, &build_tail);
 101         }
 102         printf("Total packages that would be built: %d/%d\n",
 103                BuildSuccessCount, BuildTotal);
 104 }
 105
 106 /*
 107  * Traverse the packages (pkg) depends on recursively until we find
 108  * a leaf to build or report as unbuildable.  Calculates and assigns a
 109  * dependency count.  Returns all parallel-buildable packages.
 110  *
 111  * (pkg) itself is only added to the list if it is immediately buildable.
 112  */
 113 static
 114 int
 115 status_find_leaves(pkg_t *parent, pkg_t *pkg, pkg_t ***build_tailp,
 116                   int *app, int *hasworkp, int level, int first)
 117 {
 118         pkglink_t *link;
 119         pkg_t *scan;
 120         int idep_count = 0;
 121         int apsub;
 122
 123         /*
 124          * Already on build list, possibly in-progress, tell caller that
 125          * it is not ready.
 126          */
 127         ddprintf(level, "sbuild_find_leaves %d %s %08x {\n",
 128                  level, pkg->portdir, pkg->flags);
 129         if (pkg->flags & PKGF_BUILDLIST) {
 130                 ddprintf(level, "} (already on build list)\n");
 131                 *app |= PKGF_NOTREADY;
 132                 return (pkg->idep_count);
 133         }
 134
 135         /*
 136          * Check dependencies
 137          */
 138         ++level;
 139         PKGLIST_FOREACH(link, &pkg->idepon_list) {
 140                 scan = link->pkg;
 141
 142                 if (scan == NULL)
 143                         continue;
 144                 ddprintf(level, "check %s %08x\t", scan->portdir, scan->flags);
 145
 146                 /*
 147                  * When accounting for a successful build, just bump
 148                  * idep_count by one.  scan->idep_count will heavily
 149                  * overlap packages that we count down multiple branches.
 150                  *
 151                  * We must still recurse through PACKAGED packages as
 152                  * some of their dependencies might be missing.
 153                  */
 154                 if (scan->flags & PKGF_SUCCESS) {
 155                         ddprintf(0, "SUCCESS - OK\n");
 156                         ++idep_count;
 157                         continue;
 158                 }
 159                 if (scan->flags & PKGF_ERROR) {
 160                         ddprintf(0, "ERROR - OK (propagate failure upward)\n");
 161                         *app |= PKGF_NOBUILD_S;
 162                         continue;
 163                 }
 164                 if (scan->flags & PKGF_NOBUILD) {
 165                         ddprintf(0, "NOBUILD - OK "
 166                                     "(propagate failure upward)\n");
 167                         *app |= PKGF_NOBUILD_S;
 168                         continue;
 169                 }
 170
 171                 /*
 172                  * If already on build-list this dependency is not ready.
 173                  */
 174                 if (scan->flags & PKGF_BUILDLIST) {
 175                         ddprintf(0, " [BUILDLIST]");
 176                         *app |= PKGF_NOTREADY;
 177                 }
 178
 179                 /*
 180                  * If not packaged this dependency is not ready for
 181                  * the caller.
 182                  */
 183                 if ((scan->flags & PKGF_PACKAGED) == 0) {
 184                         ddprintf(0, " [NOT_PACKAGED]");
 185                         *app |= PKGF_NOTREADY;
 186                 }
 187
 188                 /*
 189                  * Reduce search complexity, if we have already processed
 190                  * scan in the traversal it will either already be on the
 191                  * build list or it will not be buildable.  Either way
 192                  * the parent is not buildable.
 193                  */
 194                 if (scan->flags & PKGF_BUILDTRAV) {
 195                         ddprintf(0, " [BUILDTRAV]\n");
 196                         *app |= PKGF_NOTREADY;
 197                         continue;
 198                 }
 199
 200                 /*
 201                  * Assert on dependency loop
 202                  */
 203                 ++idep_count;
 204                 if (scan->flags & PKGF_BUILDLOOP) {
 205                         dfatal("pkg dependency loop %s -> %s",
 206                                 parent->portdir, scan->portdir);
 207                 }
 208                 scan->flags |= PKGF_BUILDLOOP;
 209                 apsub = 0;
 210                 ddprintf(0, " SUBRECURSION {\n");
 211                 idep_count += status_find_leaves(pkg, scan, build_tailp,
 212                                                 &apsub, hasworkp,
 213                                                 level + 1, first);
 214                 scan->flags &= ~PKGF_BUILDLOOP;
 215                 *app |= apsub;
 216                 if (apsub & PKGF_NOBUILD) {
 217                         ddprintf(level, "} (sub-nobuild)\n");
 218                 } else if (apsub & PKGF_ERROR) {
 219                         ddprintf(level, "} (sub-error)\n");
 220                 } else if (apsub & PKGF_NOTREADY) {
 221                         ddprintf(level, "} (sub-notready)\n");
 222                 } else {
 223                         ddprintf(level, "} (sub-ok)\n");
 224                 }
 225         }
 226         --level;
 227         pkg->idep_count = idep_count;
 228         pkg->flags |= PKGF_BUILDTRAV;
 229
 230         /*
 231          * Incorporate scan results into pkg state.
 232          */
 233         if ((pkg->flags & PKGF_NOBUILD) == 0 && (*app & PKGF_NOBUILD)) {
 234                 *hasworkp = 1;
 235         } else if ((pkg->flags & PKGF_ERROR) == 0 && (*app & PKGF_ERROR)) {
 236                 *hasworkp = 1;
 237         }
 238         pkg->flags |= *app & ~PKGF_NOTREADY;
 239
 240         /*
 241          * Clear PACKAGED bit if sub-dependencies aren't clean
 242          */
 243         if ((pkg->flags & PKGF_PACKAGED) &&
 244             (pkg->flags & (PKGF_NOTREADY|PKGF_ERROR|PKGF_NOBUILD))) {
 245                 pkg->flags &= ~PKGF_PACKAGED;
 246                 ddassert(pkg->pkgfile);
 247                 *hasworkp = 1;
 248         }
 249
 250         /*
 251          * Handle propagated flags
 252          */
 253         if (pkg->flags & PKGF_ERROR) {
 254                 ddprintf(level, "} (ERROR - %s)\n", pkg->portdir);
 255         } else if (pkg->flags & PKGF_NOBUILD) {
 256                 ddprintf(level, "} (SKIPPED - %s)\n", pkg->portdir);
 257         } else if (*app & PKGF_NOTREADY) {
 258                 /*
 259                  * We don't set PKGF_NOTREADY in the pkg, it is strictly
 260                  * a transient flag propagated via build_find_leaves().
 261                  *
 262                  * Just don't add the package to the list.
 263                  */
 264                 ;
 265         } else if (pkg->flags & PKGF_SUCCESS) {
 266                 ddprintf(level, "} (SUCCESS - %s)\n", pkg->portdir);
 267         } else if (pkg->flags & PKGF_DUMMY) {
 268                 /*
 269                  * Just mark dummy packages as successful when all of their
 270                  * sub-depends (flavors) complete successfully.  Note that
 271                  * dummy packages are not counted in the total, so do not
 272                  * decrement BuildTotal.
 273                  */
 274                 ddprintf(level, "} (DUMMY/META - SUCCESS)\n");
 275                 pkg->flags |= PKGF_SUCCESS;
 276                 *hasworkp = 1;
 277                 if (first) {
 278                         dlog(DLOG_ALL | DLOG_FILTER,
 279                              "[XXX] %s META-ALREADY-BUILT\n",
 280                              pkg->portdir);
 281                 } else {
 282                         dlog(DLOG_SUCC | DLOG_FILTER,
 283                              "[XXX] %s meta-node complete\n",
 284                              pkg->portdir);
 285                 }
 286         } else if (pkg->flags & PKGF_PACKAGED) {
 287                 /*
 288                  * We can just mark the pkg successful.  If this is
 289                  * the first pass, we count this as an initial pruning
 290                  * pass and reduce BuildTotal.
 291                  */
 292                 ddprintf(level, "} (PACKAGED - SUCCESS)\n");
 293                 pkg->flags |= PKGF_SUCCESS;
 294                 *hasworkp = 1;
 295                 if (first) {
 296                         dlog(DLOG_ALL | DLOG_FILTER,
 297                             "[XXX] %s ALREADY-BUILT\n",
 298                              pkg->portdir);
 299                         --BuildTotal;
 300                 }
 301         } else {
 302                 /*
 303                  * All dependencies are successful, queue new work
 304                  * and indicate not-ready to the parent (since our
 305                  * package has to be built).
 306                  */
 307                 *hasworkp = 1;
 308                 ddprintf(level, "} (ADDLIST - %s)\n", pkg->portdir);
 309                 pkg->flags |= PKGF_BUILDLIST;
 310                 **build_tailp = pkg;
 311                 *build_tailp = &pkg->build_next;
 312                 *app |= PKGF_NOTREADY;
 313         }
 314
 315         return idep_count;
 316 }
 317
 318 static
 319 void
 320 status_clear_trav(pkg_t *pkg)
 321 {
 322         pkglink_t *link;
 323         pkg_t *scan;
 324
 325         pkg->flags &= ~PKGF_BUILDTRAV;
 326         PKGLIST_FOREACH(link, &pkg->idepon_list) {
 327                 scan = link->pkg;
 328                 if (scan && (scan->flags & PKGF_BUILDTRAV))
 329                         status_clear_trav(scan);
 330         }
 331 }
 332
 333 /*
 334  * This is a fake startbuild() which just marks the build list as built,
 335  * allowing us to resolve the build tree.
 336  */
 337 static
 338 void
 339 startstatus(pkg_t **build_listp, pkg_t ***build_tailp)
 340 {
 341         pkg_t *pkg;
 342
 343         /*
 344          * Nothing to do
 345          */
 346         if (*build_listp == NULL)
 347                 return;
 348
 349         /*
 350          * Sort
 351          */
 352         for (pkg = *build_listp; pkg; pkg = pkg->build_next) {
 353                 if ((pkg->flags & (PKGF_SUCCESS | PKGF_FAILURE |
 354                                    PKGF_ERROR | PKGF_NOBUILD |
 355                                    PKGF_RUNNING)) == 0) {
 356                         pkg->flags |= PKGF_SUCCESS;
 357                         ++BuildSuccessCount;
 358                         ++BuildCount;
 359                         pkg->flags &= ~PKGF_BUILDLIST;
 360                         printf("  N => %s\n", pkg->portdir);
 361                         /* XXX [R]ebuild and [U]pgrade */
 362                 }
 363
 364         }
 365         *build_listp = NULL;
 366         *build_tailp = build_listp;
 367 }