Question

我正在尝试编写一个需要发送电子邮件的gjs应用程序。我发现执行此操作的方法是使用spawn_async_with_pipes（）调用邮件。该应用程序似乎产生了邮件，并且我没有收到错误消息，但是我没有得到任何有用的输出，也没有得到测试电子邮件...

我已经有一段时间了，发现很少或没有有用的最新文档。我正在使用gtk3和gjs（和glib）。我也尝试过生成一个反过来调用邮件的shell脚本。这导致“无法解析主机”错误和死信队列。所以我知道我正在生成命令。我并不担心“无法解析主机命令”，但是由于我无法通过直接产生邮件来获取它。

我正在生成这样的邮件：

const [res, pid, in_fd, out_fd, err_fd] =
await GLib.spawn_async_with_pipes(null,
                                              ['mail',
                                              '-V',
                                              `-s "${msgObj.subBlock}"`,
                                              `-r ${to}`,
                                              `-S smtp=${HOST}`,
                                              '-S smtp-use-starttls',
                                              '-S smtp-auth=login',
                                              `-S smtp-auth-user=${USER}`,
                                              `-S smtp-auth-password=${PASS}`,
                                              FROM
                                              ], null, GLib.SpawnFlags.SEARCH_PATH, null);

const in_reader = new Gio.DataOutputStream({
        base_stream: new Gio.UnixOutputStream({fd: in_fd})
      });
      var feedRes = in_reader.put_string(msgObj.msgBlock, null);

      const out_reader = new Gio.DataInputStream({
        base_stream: new Gio.UnixInputStream({fd: out_fd})
      });
      const err_reader = new Gio.DataInputStream({
        base_stream: new Gio.UnixInputStream({fd: err_fd})
      });
      var out = out_reader.read_until("", null);
      var err = err_reader.read_until("", null);

      print(` > out : "${out}"`);
      print(` > res : "${res}"`);
      print(` > feedRes : "${feedRes}"`);
      print(` > err : "${err}"`);

err是0，而res只是true

我不知道输出应该是什么，但是我没有发现可识别的错误，也没有发送电子邮件... 我如何让我的应用发送电子邮件？产卵不是要走的路吗？预先感谢您可以给我的任何指点。

Answer 1

我认为这里有些事情让您感到困惑，我想我可以解决。

await GLib.spawn_async_with_pipes(

GLib有其自己的异步功能概念，适用时需要包装在Promise中以与await关键字一起有效地工作。在这种情况下，GLib.spawn_async_with_pipes()不是您所考虑的异步方式，但这没关系，因为我们将使用更高级别的类Gio.Subprocess。

async function mail(msgObj, to, host, user, pass, cancellable = null) {
    try {
        let proc = new Gio.Subprocess({
            argv: ['mail',
                   '-V',
                   // Option switches and values are separate args
                   '-s', `"${msgObj.subBlock}"`,
                   '-r', `${to}`,
                   '-S', `smtp=${host}`,
                   '-S', 'smtp-use-starttls',
                   '-S', 'smtp-auth=login',
                   '-S', `smtp-auth-user=${user}`,
                   '-S', `smtp-auth-password=${pass}`,
                   FROM
            ],
            flags: Gio.SubprocessFlags.STDIN_PIPE |
                   Gio.SubprocessFlags.STDOUT_PIPE |
                   Gio.SubprocessFlags.STDERR_MERGE
        });
        // Classes that implement GInitable must be initialized before use, but
        // you could use Gio.Subprocess.new(argv, flags) which will call this for you
        proc.init(cancellable);

        // We're going to wrap a GLib async function in a Promise so we can
        // use it like a native JavaScript async function.
        //
        // You could alternatively return this Promise instead of awaiting it
        // here, but that's up to you.
        let stdout = await new Promise((resolve, reject) => {

            // communicate_utf8() returns a string, communicate() returns a
            // a GLib.Bytes and there are "headless" functions available as well
            proc.communicate_utf8_async(
                // This is your stdin, which can just be a JS string
                msgObj.msgBlock,

                // we've been passing this around from the function args; you can
                // create a Gio.Cancellable and call `cancellable.cancel()` to
                // stop the command or any other operation you've passed it to at
                // any time, which will throw an "Operation Cancelled" error.
                cancellable,

                // This is the GAsyncReady callback, which works like any other
                // callback, but we need to ensure we catch errors so we can
                // propagate them with `reject()` to make the Promise work
                // properly
                (proc, res) => {
                    try {
                        let [ok, stdout, stderr] = proc.communicate_utf8_finish(res);
                        // Because we used the STDERR_MERGE flag stderr will be
                        // included in stdout. Obviously you could also call
                        // `resolve([stdout, stderr])` if you wanted to keep both
                        // and separate them.
                        // 
                        // This won't affect whether the proc actually return non-
                        // zero causing the Promise to reject()
                        resolve(stdout);
                    } catch (e) {
                        reject(e);
                    }
                }
            );
        });

        return stdout;
    } catch (e) {
        // This could be any number of errors, but probably it will be a GError
        // in which case it will have `code` property carrying a GIOErrorEnum
        // you could use to programmatically respond to, if desired.
        logError(e);
    }
}

整体而言，

Gio.Subprocess是一个更好的选择，但对于不能将“输出”参数传递给函数的语言绑定而言，尤其如此。使用GLib.spawn_async_with_pipes通常会传入NULL，以防止打开不需要的管道，并始终确保关闭不需要的管道。由于我们无法在GJS中执行此操作，因此您最终会遇到无法关闭的文件描述符。

Gio.Subprocess为您完成了很多工作，并确保文件描述符关闭，防止僵尸进程，为您设置子级监视以及您真正不想担心的其他事情。它还具有获取IO流的便捷功能，因此您无需包装fd自己，还有其他有用的东西。

我写了一篇关于GJS异步编程的更长篇文章，您可能会发现有帮助的here。您应该很快就能轻松完成，并且尝试清除有关GLib异步，JavaScript异步以及GLib主循环与JS事件循环之间关系的困惑。

如何从gjs gtk应用程序发送电子邮件（派生邮件）

1 个答案: