Some systems have uname(2) return > 0.

[sw-tools] / src / sw_build.c

/* -*-c-*-
 *
 * $Id: sw_build.c,v 1.4 1999/09/16 12:53:46 mdw Exp $
 *
 * Management of build processes
 *
 * (c) 1999 EBI
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of sw-tools.
 *
 * sw-tools is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * sw-tools is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with sw-tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: sw_build.c,v $
 * Revision 1.4  1999/09/16 12:53:46  mdw
 * Some systems have uname(2) return > 0.
 *
 * Revision 1.3  1999/09/10 15:27:33  mdw
 * Include `%'-escape substitution.
 *
 * Revision 1.2  1999/07/16 12:50:24  mdw
 * Improve exit status display.  New interface from `doto' project.
 *
 * Revision 1.1.1.1  1999/06/02 16:53:34  mdw
 * Initial import.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/utsname.h>

#ifndef DECL_ENVIRON
  extern char **environ;
#endif

#include <mLib/alloc.h>
#include <mLib/dstr.h>
#include <mLib/exc.h>
#include <mLib/quis.h>
#include <mLib/report.h>

#include "sw.h"
#include "sw_arch.h"
#include "sw_build.h"
#include "sw_info.h"
#include "sw_rsh.h"

#define PRES_LINK 0
#define PRES_DEFAULT 0
#define PRES_PREFERENCE 0
#include "pres_plain.h"
#include "pres_curses.h"

/*----- Data structures ---------------------------------------------------*/

/*----- Static variables --------------------------------------------------*/

static pres *preslist = PRES_LINK;

/*----- Main code ---------------------------------------------------------*/

/* --- @swbuild_archlist@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to the build information block
 *
 * Returns:	A list of architectures which are to be built.
 *
 * Use:		Decides which architectures need building, and returns them
 *		in a list.
 */

archcons *swbuild_archlist(swinfo *sw)
{
  archcons *a = arch_readtab();
  const char *only = 0;
  unsigned and = 0, xor = 0;

  /* --- Restrict the architecture list appropriately --- */

  only = opt_arch ? opt_arch : sw->only_arch;

  /* --- Apply the built flags --- */

  if (!(opt_flags & optFlag_force) && sw->arch) {
    archcons *aa = arch_filter(a, sw->arch, 0, 0);
    archcons *c;
    for (c = aa; c; c = c->cdr)
      c->car->flags |= archFlag_built;
    arch_free(aa);
    and |= archFlag_built;
  }

  return (arch_filter(a, only, and, xor));
}

/*----- Main build command ------------------------------------------------*/

/* --- @sw_run@ --- *
 *
 * Arguments:	@int argc@ = number of command line arguments
 *		@char *argv[]@ = array of command line arguments
 *
 * Returns:	Zero on success (all builds OK) or nonzero for failure.
 *
 * Use:		Runs a multi-architecture build.
 */

int sw_run(int argc, char *argv[])
{
  swinfo sw;
  archcons *a;
  pres *p = PRES_DEFAULT;
  fd_set fdin;
  int active = 0;
  int maxfd = 0;
  int rc = 0;

  /* --- Handle help on output styles --- */

  if (opt_output && strcmp(opt_output, "help") == 0) {
    printf("Presentation styles supported:");
    for (p = preslist; p; p = p->next)
      printf(" %s", p->name);
    putc('\n', stdout);
    printf("The default presentation style is %s\n", (PRES_DEFAULT)->name);
    exit(0);
  } 

  /* --- Validate arguments --- */

  if (!argv[1])
    die(1, "Usage: run COMMAND [ARG...]");

  /* --- Choose an output presentation style --- */

  if (opt_output) {
    pres *q;
    size_t sz = strlen(opt_output);
    p = 0;

    for (q = preslist; q; q = q->next) {
      if (strncmp(opt_output, q->name, sz) == 0) {
	if (q->name[sz] == 0) {
	  p = q;
	  break;
	} else if (p)
	  die(1, "ambiguous output style `%s'", opt_output);
	else
	  p = q;
      }
    }

    if (!p)
      die(1, "unknown output style `%s'", opt_output);
  }

  if (p->ok && !p->ok()) {
    moan("output style `%s' can't run; using `plain' instead", p->name);
    p = &pres_plain;
  }

  /* --- Decide on an architecture --- */

  if (swinfo_fetch(&sw)) {
    die(1, "couldn't read build status: %s (try running setup)",
	strerror(errno));
  }
  swinfo_sanity(&sw);
  a = swbuild_archlist(&sw);

  if (!a) {
    moan("All desired architectures already built OK.");
    moan("(Perhaps you forgot `--force', or want to say `%s reset'.)", QUIS);
    return (0);
  }

  /* --- Tie on remote context blocks, and crank up the presentation --- */

  {
    archcons *aa;

    for (aa = a; aa; aa = aa->cdr)
      aa->car->r = xmalloc(sizeof(sw_remote));
    if (p->init && p->init(a))
      die(1, "presentation style refused to start: %s", strerror(errno));
  }

  signal(SIGINT, SIG_IGN);
  signal(SIGQUIT, SIG_IGN);

  /* --- Trap any exceptions coming this way --- *
   *
   * It's important, for example, that a curses-based presentation system
   * reset the terminal flags appropriately.
   */

  TRY {
    /* --- Run remote build processes on the remote hosts --- */

    {
      archcons *aa;
      dstr d = DSTR_INIT;
      char **av;
      struct utsname u;

      /* --- Fill in the hostname --- */

      if (uname(&u) < 0)
	strcpy(u.nodename, "<unknown>");

      /* --- If necessary, set up the output @argv@ array --- */

      if (opt_flags & optFlag_percent)
	av = xmalloc(argc * sizeof(char *));
      else
	av = argv + 1;

      /* --- Run through the target build hosts --- */

      FD_ZERO(&fdin);
      for (aa = a; aa; aa = aa->cdr) {
	archent *e = aa->car;
	sw_remote *r = e->r;

	/* --- If necessary, translate `%'-escapes --- */

	if (opt_flags & optFlag_percent) {
	  char **pp, **qq;

	  for (pp = argv + 1, qq = av; *pp; pp++, qq++) {
	    if (strchr(*pp, '%') == 0)
	      *qq = *pp;
	    else {
	      char *p;
	      char *q = *pp;
	      for (p = *pp; *p; p++) {
		if (*p == '%') {
		  DPUTM(&d, q, p - q);
		  p++;
		  switch (*p) {
		    case 0:
		      DPUTC(&d, '%');
		      goto done_arg;
		    case '%':
		      DPUTC(&d, '%');
		      break;
		    case 'a':
		      dstr_puts(&d, e->arch);
		      break;
		    case 'h':
		      dstr_puts(&d, e->flags & archFlag_home ?
				      u.nodename : e->host);
		      break;
		    case 'P':
		      dstr_puts(&d, PREFIX);
		      break;
		    case 'p':
		      dstr_puts(&d, sw.package);
		      break;
		    case 'v':
		      dstr_puts(&d, sw.version);
		      break;
		    case 'u':
		      dstr_puts(&d, sw.maintainer);
		      break;
		    default:
		      DPUTC(&d, '%');
		      DPUTC(&d, *p);
		      break;
		  }
		  q = p + 1;
		}
	      }
	      DPUTM(&d, q, p - q);
	    done_arg:
	      DPUTZ(&d);
	      *qq = xstrdup(d.buf);
	      DRESET(&d);
	    }
	  }
	  *qq++ = 0;
	}

	/* --- Start a new process off --- */

	if (swrsh(r, e->flags & archFlag_home ? 0 : e->host,
		  "build", av)) {
	  dstr d = DSTR_INIT;
	  dstr_putf(&d, "%s: couldn't start build for architecture `%s': %s",
		    QUIS, e->arch, strerror(errno));
	  p->output(e, d.buf, d.len);
	  free(r);
	  e->r = 0;
	  dstr_destroy(&d);
	} else {
	  int fd = r->fdin;
	  if (fd > maxfd)
	    maxfd = fd;
	  active++;
	  FD_SET(fd, &fdin);
	}

	/* --- Free up the argument array --- */

	if (opt_flags & optFlag_percent) {
	  char **pp, **qq;

	  for (pp = argv + 1, qq = av; *pp; pp++, qq++) {
	    if (*pp != *qq)
	      free(*qq);
	  }
	}
      }

      if (opt_flags & optFlag_percent)
	free(av);
    }

    /* --- Watch the builds until they do something interesting --- */

    maxfd++;
    while (active) {
      fd_set f;
      int n;
      archcons *aa;

      /* --- Find out what interesting things are happening --- */

      memcpy(&f, &fdin, sizeof(f));
      n = select(maxfd, &f, 0, 0, 0);
      if (n < 0) {
	if (errno == EINTR || errno == EAGAIN)
	  continue;
	else
	  THROW(EXC_ERRNO, errno);
      }

      /* --- Scan through for jobs which need attention --- */

      for (aa = a; aa; aa = aa->cdr) {
	archent *e = aa->car;
	sw_remote *r = e->r;
	int t;

	if (!FD_ISSET(r->fdin, &f))
	  continue;

	switch (t = pkrecv(r)) {

	  case PKTYPE_DATA:
	    p->output(e, r->buf, r->sz);
	    break;

	  case PKTYPE_STATUS: {
	    dstr d = DSTR_INIT;
	    int ok = 1;
	    if (r->sz != 1) {
	      r->buf[r->sz] = 0;
	      dstr_putf(&d, "failed (%s)", r->buf);
	      ok = 0;
	      rc = 1;
	    } else if (r->buf[0]) {
	      dstr_putf(&d, "failed (status %u)", (unsigned char)r->buf[0]);
	      ok = 0;
	      rc = 1;
	    } else {
	      dstr_puts(&d, "finished");
	      if (opt_flags & optFlag_install)
		e->flags |= archFlag_built;
	    }
	    if (p->close)
	      p->close(e, ok, d.buf);
	    dstr_destroy(&d);
	    FD_CLR(r->fdin, &fdin);
	    close(r->fdin);
	    active--;
	  } break;

	  case PKTYPE_EOF: {
	    if (p->close)
	      p->close(e, 0, "unexpected exit");
	    rc = 1;
	    FD_CLR(r->fdin, &fdin);
	    close(r->fdin);
	    active--;
	  } break;

	  default: {
	    const static char msg[] = "\n[Unexpected packet, type %i]\n";
	    p->output(e, msg, sizeof(msg) - 1);
	  } break;
	}
      }
    }
  }

  /* --- Handle any exceptions coming this way --- *
   *
   * I could do more cleanup here (freeing buffers and so) but it's not worth
   * it.  Nobody's bothering to catch exceptions anyway.
   */

  CATCH {
    if (p->abort)
      p->abort(a);
    switch (exc_type) {
      case EXC_ERRNO:
	die(1, "unexpected error: %s", strerror(exc_i));
	break;
      default:
	RETHROW;
	break;
    }
  } END_TRY;

  /* --- Tell the presentation that everything's done --- */

  if (p->done)
    p->done(a);
  else if (opt_flags & optFlag_beep)
    putchar('\a');

  /* --- Clean up the unwanted remote contexts --- */

  {
    archcons *aa;
    for (aa = a; aa; aa = aa->cdr)
      free(a->car->r);
  }

  /* --- Tidy away the architecture list --- */

  arch_free(a);

  /* --- Mark built architectures as having been completed now --- */

  if (opt_flags & optFlag_install) {
    swinfo skel;
    dstr d = DSTR_INIT;
    swinfo_clear(&skel);
    arch_toText(&d, arch_readtab(), archFlag_built, archFlag_built);
    skel.arch = d.buf;
    swinfo_update(&sw, &skel);
    dstr_destroy(&d);
    if (swinfo_put(&sw))
      die(1, "error writing build status: %s", strerror(errno));
  }
  return (rc);
}

/*----- Main remote entry point -------------------------------------------*/

/* --- @putf@ --- *
 *
 * Arguments:	@sw_remote *r@ = pointer to remote context
 *		@FILE *fp@ = log file handle
 *		@const char *fmt@ = format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Reports a string to the log file and the remote controller
 *		process.
 */

static void putf(sw_remote *r, FILE *fp, const char *fmt, ...)
{
  va_list ap;
  dstr d = DSTR_INIT;
  va_start(ap, fmt);
  dstr_vputf(&d, fmt, ap);
  va_end(ap);
  if (r)
    pksend(r, PKTYPE_DATA, d.buf, d.len);
  if (fp)
    fwrite(d.buf, 1, d.len, fp);
  dstr_destroy(&d);
}

/* --- @swrsh_build@ --- *
 *
 * Arguments:	@sw_remote *r@ = pointer to remote context
 *		@char *argv[]@ = pointer to argument list
 *		@char *env[]@ = pointer to environment list
 *
 * Returns:	Doesn't.
 *
 * Use:		Runs a remote build command.
 */

void swrsh_build(sw_remote *r, char *argv[], char *env[])
{
  FILE *logfp;
  int fd[2];
  pid_t kid;

  /* --- Validate the arguments --- */

  if (!argv[0])
    swdie(r, 1, "Usage: build COMMAND [ARG...]");

  /* --- Change into architecture directory --- */

  if (mkdir(ARCH, 0775) && errno != EEXIST)
    swdie(r, 1, "mkdir(`%s') failed: %s", ARCH, strerror(errno));
  if (chdir(ARCH)) {
    swdie(r, 1, "couldn't change directory to `%s': %s",
	  ARCH, strerror(errno));
  }
  if (pipe(fd))
    swdie(r, 1, "couldn't create pipe: %s", strerror(errno));

  /* --- Open the log file --- */

  {
    int logfd = open(".build-log", O_WRONLY | O_APPEND | O_CREAT, 0664);
    time_t t;
    struct tm *tm;
    char buf[64];
    char **p;
    struct utsname u;

    if (uname(&u) < 0)
      swdie(r, 1, "couldn't get hostname: %s", strerror(errno));
    if (logfd < 0)
      swdie(r, 1, "couldn't open `.build-log' file: %s", strerror(errno));
    if ((logfp = fdopen(logfd, "a")) == 0) {
      swdie(r, 1, "couldn't open stream on `.build-log' file: %s",
	    strerror(errno));
    }
    t = time(0);
    tm = localtime(&t);
    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm);
    fprintf(logfp, "\n\n*** %s: %s started build: %s",
	    buf, u.nodename, argv[0]);
    for (p = argv + 1; *p; p++)
      fprintf(logfp, " %s", *p);
    fputs("\n\n", logfp);
  }

  /* --- Start off the child process --- */

  kid = fork();
  if (kid == 0) {
    int nullfd;
    close(fd[0]);
    dup2(fd[1], 1);
    dup2(fd[1], 2);
    if (fd[1] > 2)
      close(fd[1]);
    close(0);
    nullfd = open("/dev/null", O_RDONLY);
    if (nullfd > 0) {
      dup2(nullfd, 0);
      close(nullfd);
    }
    environ = env;
    execvp(argv[0], argv);
    fprintf(stderr, "failed to start `%s': %s\n", argv[0], strerror(errno));
    _exit(127);
  }

  /* --- Read from the pipe, and write to the socket and logfile --- */

  close(fd[1]);
  for (;;) {
    ssize_t n = read(fd[0], r->buf, PKMAX);
    if (!n)
      break;
    if (n < 0) {
      putf(r, logfp, "\n*** error reading from pipe: %s\n", strerror(errno));
      kill(kid, SIGTERM);
      break;
    }
    fwrite(r->buf, 1, n, logfp);
    pksend(r, PKTYPE_DATA, r->buf, n);
  }
  close(fd[0]);

  /* --- Reap exit status and produce final report --- */

  {
    int status;
    if (waitpid(kid, &status, 0) < 0) {
      putf(r, logfp, "\n*** error reading exit status: %s\n",
	   strerror(errno));
    } else {
      if (WIFSIGNALED(status))
	fprintf(logfp, "\n*** exited on signal %i\n", WTERMSIG(status));
      else if (WIFEXITED(status))
	fprintf(logfp, "\n*** exited with status %i\n", WEXITSTATUS(status));
      else
	fprintf(logfp, "\n*** reaped, but didn't exit.  Strange\n");
    }
    fclose(logfp);
    swwait(r, status);
  }
}

/*----- Syntactic sugar ---------------------------------------------------*/

/*
 * `Syntactic sugar causes cancer of the semicolon.'
 *		-- Alan Perlis, `Epigrams in Programming'
 */

/* --- @build@ --- *
 *
 * Arguments:	@char **u@ = first segment
 *		@char **v@ = second segment
 *
 * Returns:	Return code from the build.
 *
 * Use:		Combines two @argv@-style arrays and then runs a build on the
 *		result.
 */

static int build(char **u, char **v)
{
  size_t i, j;
  char **p;

  for (i = 0, p = u; *p; p++, i++) ;
  for (j = 0, p = v; *p; p++, j++) ;
  p = xmalloc((i + j + 2) * sizeof(char **));
  memcpy(p + 1, u, i * sizeof(char **));
  memcpy(p + i + 1, v, j * sizeof(char **));
  p[0] = p[i + j + 1] = 0;
  return (sw_run(i + j + 1, p));
}

/* --- @sw_make@ --- */

int sw_make(int argc, char *argv[])
{
  static char *mk[] = { 0, 0 };
  if (!mk[0]) {
    char *m;
    if ((m = getenv("SW_MAKE")) == 0 &&
	(m = getenv("MAKE")) == 0)
      m = "make";
    mk[0] = m;
  }
  return (build(mk, argv + 1));
}

/* --- @sw_conf@ --- */

int sw_conf(int argc, char *argv[])
{
  static char *cf[] = { "../configure", "--prefix=" PREFIX, 0 };
  return (build(cf, argv + 1));
}

/*----- Other subcommands -------------------------------------------------*/

/* --- @sw_reset@ --- */

int sw_reset(int argc, char *argv[])
{
  swinfo sw, skel;
  if (argc != 1)
    die(1, "Usage: reset");
  if (swinfo_fetch(&sw)) {
    die(1, "couldn't read build status: %s (try running setup)",
	strerror(errno));
  }
  swinfo_sanity(&sw);
  swinfo_clear(&skel);
  skel.arch = "";
  swinfo_update(&sw, &skel);
  if (swinfo_put(&sw))
    die(1, "couldn't write build status: %s", strerror(errno));
  return (0);
}

/*----- That's all, folks -------------------------------------------------*/