Esempio n. 1
0
static void copy_k2f (flux_t *h, const char *src, const char *dst)
{
    kz_t *kzin;
    int dstfd = STDOUT_FILENO;
    char *data;
    int len;

    if (!(kzin = kz_open (h, src, KZ_FLAGS_READ)))
        log_err_exit ("kz_open %s", src);
    if (strcmp (dst, "-") != 0) {
        if ((dstfd = creat (dst, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0)
            log_err_exit ("%s", dst);
    }
    while ((len = kz_get (kzin, &data)) > 0) {
        if (write_all (dstfd, data, len) < 0)
            log_err_exit ("write_all %s", dst);
        free (data);
    }
    if (len < 0)
        log_err_exit ("kz_get %s", src);
    if (kz_close (kzin) < 0) 
        log_err_exit ("kz_close %s", src);
    if (dstfd != STDOUT_FILENO) {
        if (close (dstfd) < 0)
            log_err_exit ("close %s", dst);
    }
}
Esempio n. 2
0
static void copy_f2k (flux_t *h, const char *src, const char *dst,
                      int kzoutflags, int blocksize)
{
    int srcfd = STDIN_FILENO;
    kz_t *kzout;
    char *data;
    int len;

    if (strcmp (src, "-") != 0) {
        if ((srcfd = open (src, O_RDONLY)) < 0)
            log_err_exit ("%s", src);
    }
    if (!(kzout = kz_open (h, dst, kzoutflags)))
        log_err_exit ("kz_open %s", dst);
    data = xzmalloc (blocksize);
    while ((len = read (srcfd, data, blocksize)) > 0) {
        if (kz_put (kzout, data, len) < 0)
            log_err_exit ("kz_put %s", dst);
    }
    if (len < 0)
        log_err_exit ("read %s", src);
    free (data);
    if (kz_close (kzout) < 0) 
        log_err_exit ("kz_close %s", dst);
}
Esempio n. 3
0
static void copy_k2k (flux_t *h, const char *src, const char *dst,
                      int kzoutflags)
{
    kz_t *kzin, *kzout;
    char *json_str;
    bool eof = false;

    if (!(kzin = kz_open (h, src, KZ_FLAGS_READ | KZ_FLAGS_RAW)))
        log_err_exit ("kz_open %s", src);
    if (!(kzout = kz_open (h, dst, kzoutflags | KZ_FLAGS_RAW)))
        log_err_exit ("kz_open %s", dst);
    while (!eof && (json_str = kz_get_json (kzin))) {
        if (kz_put_json (kzout, json_str) < 0)
            log_err_exit ("kz_put_json %s", dst);
        eof = zio_json_eof (json_str);
        free (json_str);
    }
    if (json_str == NULL)
        log_err_exit ("kz_get %s", src);
    if (kz_close (kzin) < 0) 
        log_err_exit ("kz_close %s", src);
    if (kz_close (kzout) < 0) 
        log_err_exit ("kz_close %s", dst);
}
Esempio n. 4
0
kz_t *kz_gopen (flux_t h, const char *grpname, int nprocs,
               const char *name, int flags)
{
    kz_t *kz;

    if (!(flags & KZ_FLAGS_WRITE) || !grpname || nprocs <= 0) {
        errno = EINVAL;
        return NULL;
    }
    flags |= KZ_FLAGS_NOCOMMIT_OPEN;
    flags |= KZ_FLAGS_NOCOMMIT_CLOSE;
    if (!(kz = kz_open (h, name, flags)))
        return NULL;
    kz->grpname = xstrdup (grpname);
    kz->nprocs = nprocs;
    if (kz_fence (kz) < 0)
        goto error;
    return kz;
error:
    kz_destroy (kz);
    return NULL;
}
Esempio n. 5
0
static void attach (flux_t *h, const char *key, bool rawtty, int kzoutflags,
                    int blocksize)
{
    t_kzutil_ctx_t *ctx = xzmalloc (sizeof (*ctx));
    char *name;
    int fdin = dup (STDIN_FILENO);
    struct termios saved_tio;
    flux_reactor_t *r = flux_get_reactor (h);
    flux_watcher_t *w = NULL;

    log_msg ("process attached to %s", key);

    ctx->h = h;
    ctx->blocksize = blocksize;

    /* FIXME: need a ~. style escape sequence to terminate stdin
     * in raw mode.
     */
    if (rawtty) {
        if (fd_set_raw (fdin, &saved_tio, true) < 0)
            log_err_exit ("fd_set_raw stdin");
    }
    if (fd_set_nonblocking (fdin, true) < 0)
        log_err_exit ("fd_set_nonblocking stdin");

    if (asprintf (&name, "%s.stdin", key) < 0)
        oom ();
    if (!(ctx->kz[0] = kz_open (h, name, kzoutflags)))
        if (errno == EEXIST)
            log_err ("disabling stdin");
        else
            log_err_exit ("%s", name);
    else {
        if (!(w = flux_fd_watcher_create (r, fdin, FLUX_POLLIN,
                                attach_stdin_ready_cb, ctx)))
            log_err_exit ("flux_fd_watcher_create %s", name);
        flux_watcher_start (w);
    }
    free (name);

    if (asprintf (&name, "%s.stdout", key) < 0)
        oom ();
    if (!(ctx->kz[1] = kz_open (h, name, KZ_FLAGS_READ | KZ_FLAGS_NONBLOCK)))
        log_err_exit ("kz_open %s", name);
    if (kz_set_ready_cb (ctx->kz[1], attach_stdout_ready_cb, ctx) < 0)
        log_err_exit ("kz_set_ready_cb %s", name);
    free (name);
    ctx->readers++;

    if (asprintf (&name, "%s.stderr", key) < 0)
        oom ();
    if (!(ctx->kz[2] = kz_open (h, name, KZ_FLAGS_READ | KZ_FLAGS_NONBLOCK)))
        log_err_exit ("kz_open %s", name);
    if (kz_set_ready_cb (ctx->kz[2], attach_stderr_ready_cb, ctx) < 0)
        log_err_exit ("kz_set_ready_cb %s", name);
    free (name);
    ctx->readers++;

    /* Reactor terminates when ctx->readers reaches zero, i.e.
     * when EOF is read from remote stdout and stderr.
     * (Note: if they are already at eof, we will have already terminated
     * before the reactor is started, since kvs_watch callbacks make one
     * call to the callback in the context of the caller).
     */
    if (ctx->readers > 0) {
        if (flux_reactor_run (r, 0) < 0)
            log_err_exit ("flux_reactor_run");
    }

    (void)kz_close (ctx->kz[1]);
    (void)kz_close (ctx->kz[2]);

    /* FIXME: tty state needs to be restored on all exit paths.
     */
    if (rawtty) {
        if (fd_set_raw (fdin, &saved_tio, false) < 0)
            log_err_exit ("fd_set_raw stdin");
    }

    flux_watcher_destroy (w);
    free (ctx);
}