No OneTemporary
Actions

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/c_src/spawner.c b/c_src/spawner.c
	index cfe50cc..0eb5483 100644
	--- a/c_src/spawner.c
	+++ b/c_src/spawner.c
	@@ -1,227 +1,229 @@
	#ifndef _POSIX_C_SOURCE
	#define _POSIX_C_SOURCE 200809L
	#endif

	#include <fcntl.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <sys/wait.h>
	#include <unistd.h>

	// these definitions are Linux only at the moment
	#ifndef CMSG_LEN
	socklen_t CMSG_LEN(size_t len) {
	return (CMSG_DATA((struct cmsghdr )NULL) - (unsigned char )NULL) + len;
	}
	#endif

	#ifndef CMSG_SPACE
	socklen_t CMSG_SPACE(size_t len) {
	struct msghdr msg;
	struct cmsghdr cmsg;
	msg.msg_control = &cmsg;
	msg.msg_controllen =
	~0; /* To maximize the chance that CMSG_NXTHDR won't return NULL */
	cmsg.cmsg_len = CMSG_LEN(len);
	return (unsigned char )CMSG_NXTHDR(&msg, &cmsg) - (unsigned char )&cmsg;
	}
	#endif

	// #define DEBUG

	#ifdef DEBUG
	#define debug(...) \
	do { \
	fprintf(stderr, "%s:%d\t(fn \"%s\") - ", __FILE__, __LINE__, __func__); \
	fprintf(stderr, __VA_ARGS__); \
	+ fprintf(stderr, "\n"); \
	} while (0)
	#else
	#define debug(...)
	#endif

	#define error(...) \
	do { \
	fprintf(stderr, "%s:%d\t(fn: \"%s\") - ", __FILE__, __LINE__, __func__); \
	fprintf(stderr, __VA_ARGS__); \
	+ fprintf(stderr, "\n"); \
	} while (0)

	static const int PIPE_READ = 0;
	static const int PIPE_WRITE = 1;

	/* We are choosing an exit code which is not reserved see:
	* https://www.tldp.org/LDP/abs/html/exitcodes.html. */
	static const int FORK_EXEC_FAILURE = 125;

	static int set_flag(int fd, int flags) {
	return fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) \| flags);
	}

	static int send_io_fds(int socket, int read_fd, int write_fd) {
	struct msghdr msg = {0};
	struct cmsghdr *cmsg;
	int fds[2];
	char buf[CMSG_SPACE(2 * sizeof(int))], dup[256];
	struct iovec io;

	memset(buf, '\0', sizeof(buf));

	io.iov_base = &dup;
	io.iov_len = sizeof(dup);

	msg.msg_iov = &io;
	msg.msg_iovlen = 1;
	msg.msg_control = buf;
	msg.msg_controllen = sizeof(buf);

	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	cmsg->cmsg_len = CMSG_LEN(2 * sizeof(int));

	fds[0] = read_fd;
	fds[1] = write_fd;

	memcpy((int )CMSG_DATA(cmsg), fds, 2 sizeof(int));

	if (sendmsg(socket, &msg, 0) < 0) {
	debug("Failed to send message");
	return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
	}

	/* This is not ideal, but as of now there is no portable way to do this */
	-static void close_all_non_io_fds() {
	+static void close_all_non_std_fds() {
	int fd_limit = (int)sysconf(_SC_OPEN_MAX);
	for (int i = STDERR_FILENO + 1; i < fd_limit; i++)
	close(i);
	}

	static void close_pipes(int pipes[2][2]) {
	for (int i = 0; i < 2; i++) {
	if (pipes[i][PIPE_READ] > 0)
	close(pipes[i][PIPE_READ]);
	if (pipes[i][PIPE_WRITE] > 0)
	close(pipes[i][PIPE_WRITE]);
	}
	}

	static int exec_process(char const bin, char const *args, int socket) {
	int pipes[2][2] = {{0, 0}, {0, 0}};
	int r_cmdin, w_cmdin, r_cmdout, w_cmdout;

	if (pipe(pipes[STDIN_FILENO]) == -1 \|\| pipe(pipes[STDOUT_FILENO]) == -1) {
	perror("[spawner] failed to create pipes");
	close_pipes(pipes);
	return 1;
	}

	debug("created pipes");

	r_cmdin = pipes[STDIN_FILENO][PIPE_READ];
	w_cmdin = pipes[STDIN_FILENO][PIPE_WRITE];

	r_cmdout = pipes[STDOUT_FILENO][PIPE_READ];
	w_cmdout = pipes[STDOUT_FILENO][PIPE_WRITE];

	if (set_flag(r_cmdin, O_CLOEXEC) < 0 \|\| set_flag(w_cmdout, O_CLOEXEC) < 0 \|\|
	set_flag(w_cmdin, O_CLOEXEC \| O_NONBLOCK) < 0 \|\|
	set_flag(r_cmdout, O_CLOEXEC \| O_NONBLOCK) < 0) {
	perror("[spawner] failed to set flags for pipes");
	close_pipes(pipes);
	return 1;
	}

	debug("set fd flags to pipes");

	if (send_io_fds(socket, w_cmdin, r_cmdout) != EXIT_SUCCESS) {
	perror("[spawner] failed to send fd via socket");
	close_pipes(pipes);
	return 1;
	}

	debug("sent fds over UDS");

	close(STDIN_FILENO);
	close(w_cmdin);
	if (dup2(r_cmdin, STDIN_FILENO) < 0) {
	perror("[spawner] failed to dup to stdin");
	_exit(FORK_EXEC_FAILURE);
	}

	close(STDOUT_FILENO);
	close(r_cmdout);
	if (dup2(w_cmdout, STDOUT_FILENO) < 0) {
	perror("[spawner] failed to dup to stdout");
	_exit(FORK_EXEC_FAILURE);
	}

	// Note that we are not closing STDERR
	- close_all_non_io_fds();
	+ close_all_non_std_fds();

	debug("exec %s", bin);

	execvp(bin, args);
	perror("[spawner] execvp(): failed");

	_exit(FORK_EXEC_FAILURE);
	}

	static int spawn(const char socket_path, const char bin, char const args) {
	int socket_fd;
	struct sockaddr_un socket_addr;

	socket_fd = socket(AF_UNIX, SOCK_STREAM, 0);

	if (socket_fd == -1) {
	debug("Failed to create socket");
	return EXIT_FAILURE;
	}

	debug("created domain socket");

	memset(&socket_addr, 0, sizeof(struct sockaddr_un));
	socket_addr.sun_family = AF_UNIX;
	strncpy(socket_addr.sun_path, socket_path, sizeof(socket_addr.sun_path) - 1);

	if (connect(socket_fd, (struct sockaddr *)&socket_addr,
	sizeof(struct sockaddr_un)) == -1) {
	debug("Failed to connect to socket");
	return EXIT_FAILURE;
	}

	debug("connected to exile");

	if (exec_process(bin, args, socket_fd) != 0)
	return EXIT_FAILURE;

	// we should never reach here
	return EXIT_SUCCESS;
	}

	int main(int argc, const char *argv[]) {
	int status, i;
	const char **exec_argv;

	if (argc < 3) {
	debug("expected at least 2 arguments, passed %d", argc);
	status = EXIT_FAILURE;
	} else {
	exec_argv = malloc((argc - 2 + 1) * sizeof(char *));

	for (i = 2; i < argc; i++)
	exec_argv[i - 2] = argv[i];

	exec_argv[i - 2] = NULL;

	debug("socket path: %s bin: %s", argv[1], argv[2]);
	status = spawn(argv[1], argv[2], (char const )exec_argv);
	}

	exit(status);
	}
	diff --git a/lib/exile/process.ex b/lib/exile/process.ex
	index 65e7f51..a4bde41 100644
	--- a/lib/exile/process.ex
	+++ b/lib/exile/process.ex
	@@ -1,506 +1,510 @@
	defmodule Exile.Process do
	@moduledoc """
	GenServer which wraps spawned external command.

	`Exile.stream!/1` should be preferred over this. Use this only if you need more control over the life-cycle of IO streams and OS process.

	## Comparison with Port

	* it is demand driven. User explicitly has to `read` the command output, and the progress of the external command is controlled using OS pipes. Exile never load more output than we can consume, so we should never experience memory issues
	* it can close stdin while consuming stdout
	* tries to handle zombie process by attempting to cleanup external process. Note that there is no middleware involved with exile so it is still possbile to endup with zombie process.

	Internally Exile uses non-blocking asynchronous system calls to interact with the external process. It does not use port's message based communication, instead uses raw stdio and NIF. Uses `select()` based API for asynchronous IO. Most of the system calls are non-blocking, so it should not block the beam schedulers. Make use of dirty-schedulers for IO
	"""

	alias Exile.ProcessNif, as: Nif
	require Logger
	use GenServer

	defmodule Error do
	defexception [:message]
	end

	alias Exile.Process.Error

	@default_opts [env: []]

	@doc """
	Starts `Exile.ProcessServer`

	Starts external program using `cmd_with_args` with options `opts`

	`cmd_with_args` must be a list containing command with arguments. example: `["cat", "file.txt"]`.

	### Options
	* `cd` - the directory to run the command in
	* `env` - a list of tuples containing environment key-value. These can be accessed in the external program
	"""
	@type process :: pid
	@spec start_link(nonempty_list(String.t()),
	cd: String.t(),
	env: [{String.t(), String.t()}]
	) :: {:ok, process} \| {:error, any()}
	def start_link(cmd_with_args, opts \\ []) do
	opts = Keyword.merge(@default_opts, opts)

	with {:ok, args} <- normalize_args(cmd_with_args, opts) do
	GenServer.start(__MODULE__, args)
	end
	end

	@doc """
	Closes external program's input stream
	"""
	@spec close_stdin(process) :: :ok \| {:error, any()}
	def close_stdin(process) do
	GenServer.call(process, :close_stdin, :infinity)
	end

	@doc """
	Writes iodata `data` to program's input streams

	This blocks when the pipe is full
	"""
	@spec write(process, binary) :: :ok \| {:error, any()}
	def write(process, iodata) do
	GenServer.call(process, {:write, IO.iodata_to_binary(iodata)}, :infinity)
	end

	@doc """
	Return bytes written by the program to output stream.

	This blocks until the programs write and flush the output depending on the `size`
	"""
	@spec read(process, pos_integer()) ::
	{:ok, iodata} \| {:eof, iodata} \| {:error, any()}
	def read(process, size) when (is_integer(size) and size > 0) or size == :unbuffered do
	GenServer.call(process, {:read, size}, :infinity)
	end

	def read(process) do
	GenServer.call(process, {:read, :unbuffered}, :infinity)
	end

	@doc """
	Sends signal to external program
	"""
	@spec kill(process, :sigkill \| :sigterm) :: :ok
	def kill(process, signal) when signal in [:sigkill, :sigterm] do
	GenServer.call(process, {:kill, signal}, :infinity)
	end

	@doc """
	Waits for the program to terminate.

	If the program terminates before timeout, it returns `{:ok, exit_status}` else returns `:timeout`
	"""
	@spec await_exit(process, timeout: timeout()) :: {:ok, integer()} \| :timeout
	def await_exit(process, timeout \\ :infinity) do
	GenServer.call(process, {:await_exit, timeout}, :infinity)
	end

	@doc """
	Returns os pid of the command
	"""
	@spec os_pid(process) :: pos_integer()
	def os_pid(process) do
	GenServer.call(process, :os_pid, :infinity)
	end

	@doc """
	Stops the exile process, external program will be terminated in the background
	"""
	@spec stop(process) :: :ok
	def stop(process), do: GenServer.call(process, :stop, :infinity)

	## Server

	defmodule Pending do
	@moduledoc false
	defstruct bin: [], remaining: 0, client_pid: nil
	end

	defstruct [
	:args,
	:errno,
	:port,
	:socket_path,
	:stdin,
	:stdout,
	:context,
	:status,
	await: %{},
	pending_read: nil,
	pending_write: nil
	]

	alias __MODULE__

	def init(args) do
	state = %__MODULE__{
	args: args,
	errno: nil,
	status: :init,
	await: %{},
	pending_read: %Pending{},
	pending_write: %Pending{}
	}

	{:ok, state, {:continue, nil}}
	end

	def handle_continue(nil, state) do
	Elixir.Process.flag(:trap_exit, true)
	-
	- %{cmd_with_args: cmd_with_args, cd: cd, env: env} = state.args
	- socket_path = socket_path()
	-
	- uds = create_unix_domain_socket!(socket_path)
	-
	- port = exec(cmd_with_args, socket_path, env, cd)
	- {:os_pid, os_pid} = Port.info(port, :os_pid)
	- Exile.Watcher.watch(self(), os_pid, socket_path)
	-
	- {write_fd, read_fd} = receive_file_descriptors!(uds)
	-
	- {:noreply,
	- %Process{
	- state
	- \| port: port,
	- status: :start,
	- socket_path: socket_path,
	- stdin: read_fd,
	- stdout: write_fd
	- }}
	+ {:noreply, start_process(state)}
	end

	def handle_call(:stop, _from, state) do
	# TODO: pending write and read should receive "stopped" return
	# value instead of exit signal
	case state.status do
	{:exit, _} -> :ok
	_ -> Port.close(state.port)
	end

	{:stop, :normal, :ok, state}
	end

	def handle_call(:close_stdin, _from, state) do
	case state.status do
	{:exit, _} -> {:reply, :ok, state}
	_ -> do_close(state, :stdin)
	end
	end

	def handle_call({:await_exit, _}, _from, %{status: {:exit, status}} = state) do
	{:reply, {:ok, {:exit, status}}, state}
	end

	def handle_call({:await_exit, timeout}, from, %{status: :start} = state) do
	tref =
	if timeout != :infinity do
	Elixir.Process.send_after(self(), {:await_exit_timeout, from}, timeout)
	else
	nil
	end

	{:noreply, %Process{state \| await: Map.put(state.await, from, tref)}}
	end

	def handle_call(_, _from, %{status: {:exit, status}} = state) do
	{:reply, {:error, {:exit, status}}, state}
	end

	def handle_call({:write, binary}, from, state) do
	cond do
	!is_binary(binary) ->
	{:reply, {:error, :not_binary}, state}

	state.pending_write.client_pid ->
	{:reply, {:error, :pending_write}, state}

	true ->
	pending = %Pending{bin: binary, client_pid: from}
	do_write(%Process{state \| pending_write: pending})
	end
	end

	def handle_call({:read, size}, from, state) do
	if state.pending_read.client_pid do
	{:reply, {:error, :pending_read}, state}
	else
	pending = %Pending{remaining: size, client_pid: from}
	do_read(%Process{state \| pending_read: pending})
	end
	end

	def handle_call(:os_pid, _from, state) do
	case Port.info(state.port, :os_pid) do
	{:os_pid, os_pid} ->
	{:reply, {:ok, os_pid}, state}

	:undefined ->
	Logger.debug("Process not alive")
	{:reply, :undefined, state}
	end
	end

	def handle_call({:kill, signal}, _from, state) do
	{:reply, signal(state.port, signal), state}
	end

	def handle_info({:await_exit_timeout, from}, state) do
	GenServer.reply(from, :timeout)
	{:noreply, %Process{state \| await: Map.delete(state.await, from)}}
	end

	def handle_info({:select, _write_resource, _ref, :ready_output}, state), do: do_write(state)

	def handle_info({:select, _read_resource, _ref, :ready_input}, state), do: do_read(state)

	def handle_info({port, {:exit_status, exit_status}}, %{port: port} = state),
	do: handle_port_exit(exit_status, state)

	def handle_info({:EXIT, port, :normal}, %{port: port} = state), do: {:noreply, state}

	def handle_info({:EXIT, _, reason}, state), do: {:stop, reason, state}

	defp handle_port_exit(exit_status, state) do
	Enum.each(state.await, fn {from, tref} ->
	GenServer.reply(from, {:ok, {:exit, exit_status}})

	if tref do
	Elixir.Process.cancel_timer(tref)
	end
	end)

	{:noreply, %Process{state \| status: {:exit, exit_status}}, await: %{}}
	end

	defp do_write(%Process{pending_write: %Pending{bin: <<>>}} = state) do
	GenServer.reply(state.pending_write.client_pid, :ok)
	{:noreply, %{state \| pending_write: %Pending{}}}
	end

	defp do_write(%Process{pending_write: pending} = state) do
	case Nif.nif_write(state.stdin, pending.bin) do
	{:ok, size} ->
	if size < byte_size(pending.bin) do
	binary = binary_part(pending.bin, size, byte_size(pending.bin) - size)
	{:noreply, %{state \| pending_write: %Pending{pending \| bin: binary}}}
	else
	GenServer.reply(pending.client_pid, :ok)
	{:noreply, %{state \| pending_write: %Pending{}}}
	end

	{:error, :eagain} ->
	{:noreply, state}

	{:error, errno} ->
	GenServer.reply(pending.client_pid, {:error, errno})
	{:noreply, %{state \| errno: errno}}
	end
	end

	defp do_read(%Process{pending_read: %Pending{remaining: :unbuffered} = pending} = state) do
	case Nif.nif_read(state.stdout, -1) do
	{:ok, <<>>} ->
	GenServer.reply(pending.client_pid, {:eof, []})
	{:noreply, %Process{state \| pending_read: %Pending{}}}

	{:ok, binary} ->
	GenServer.reply(pending.client_pid, {:ok, binary})
	{:noreply, %Process{state \| pending_read: %Pending{}}}

	{:error, :eagain} ->
	{:noreply, state}

	{:error, errno} ->
	GenServer.reply(pending.client_pid, {:error, errno})
	{:noreply, %Process{state \| pending_read: %Pending{}, errno: errno}}
	end
	end

	defp do_read(%Process{pending_read: pending} = state) do
	case Nif.nif_read(state.stdout, pending.remaining) do
	{:ok, <<>>} ->
	GenServer.reply(pending.client_pid, {:eof, pending.bin})
	{:noreply, %Process{state \| pending_read: %Pending{}}}

	{:ok, binary} ->
	if byte_size(binary) < pending.remaining do
	pending = %Pending{
	pending
	\| bin: [pending.bin \| binary],
	remaining: pending.remaining - byte_size(binary)
	}

	{:noreply, %Process{state \| pending_read: pending}}
	else
	GenServer.reply(pending.client_pid, {:ok, [state.pending_read.bin \| binary]})
	{:noreply, %Process{state \| pending_read: %Pending{}}}
	end

	{:error, :eagain} ->
	{:noreply, state}

	{:error, errno} ->
	GenServer.reply(pending.client_pid, {:error, errno})
	{:noreply, %{state \| pending_read: %Pending{}, errno: errno}}
	end
	end

	defp do_close(state, type) do
	fd =
	if type == :stdin do
	state.stdin
	else
	state.stdout
	end

	case Nif.nif_close(fd) do
	:ok ->
	{:reply, :ok, state}

	{:error, errno} ->
	# FIXME: correct
	raise errno
	{:reply, {:error, errno}, %Process{state \| errno: errno}}
	end
	end

	defp normalize_cmd([cmd \| _]) when is_binary(cmd) do
	path = System.find_executable(cmd)

	if path do
	{:ok, to_charlist(path)}
	else
	{:error, "command not found: #{inspect(cmd)}"}
	end
	end

	defp normalize_cmd(_cmd_with_args) do
	{:error, "`cmd_with_args` must be a list of strings, Please check the documentation"}
	end

	defp normalize_cmd_args([_ \| args]) do
	if is_list(args) && Enum.all?(args, &is_binary/1) do
	{:ok, Enum.map(args, &to_charlist/1)}
	else
	{:error, "command arguments must be list of strings. #{inspect(args)}"}
	end
	end

	defp normalize_cd(nil), do: {:ok, ''}

	defp normalize_cd(cd) do
	if File.exists?(cd) && File.dir?(cd) do
	{:ok, to_charlist(cd)}
	else
	{:error, "`:cd` must be valid directory path"}
	end
	end

	defp normalize_env(nil), do: {:ok, []}

	defp normalize_env(env) do
	env =
	Enum.map(env, fn {key, value} ->
	{to_charlist(key), to_charlist(value)}
	end)

	{:ok, env}
	end

	defp validate_opts_fields(opts) do
	{_, additional_opts} = Keyword.split(opts, [:cd, :env])

	if Enum.empty?(additional_opts) do
	:ok
	else
	{:error, "invalid opts: #{inspect(additional_opts)}"}
	end
	end

	defp normalize_args(cmd_with_args, opts) do
	with {:ok, cmd} <- normalize_cmd(cmd_with_args),
	{:ok, args} <- normalize_cmd_args(cmd_with_args),
	:ok <- validate_opts_fields(opts),
	{:ok, cd} <- normalize_cd(opts[:cd]),
	{:ok, env} <- normalize_env(opts[:env]) do
	{:ok, %{cmd_with_args: [cmd \| args], cd: cd, env: env}}
	end
	end

	@spawner_path :filename.join(:code.priv_dir(:exile), "spawner")

	defp exec(cmd_with_args, socket_path, env, cd) do
	opts = []
	opts = if cd, do: [{:cd, cd} \| opts], else: []
	opts = if env, do: [{:env, env} \| opts], else: opts

	opts =
	[
	:nouse_stdio,
	:exit_status,
	:binary,
	args: [socket_path \| cmd_with_args]
	] ++ opts

	Port.open({:spawn_executable, @spawner_path}, opts)
	end

	defp socket_path do
	str = :crypto.strong_rand_bytes(16) \|> Base.url_encode64() \|> binary_part(0, 16)
	path = Path.join(System.tmp_dir!(), str)
	_ = :file.delete(path)
	path
	end

	defp signal(port, sig) when sig in [:sigkill, :sigterm] do
	case Port.info(port, :os_pid) do
	{:os_pid, os_pid} -> Nif.nif_kill(os_pid, sig)
	:undefined -> {:error, :process_not_alive}
	end
	end

	- defp create_unix_domain_socket!(socket_path) do
	- {:ok, uds} = :socket.open(:local, :stream, :default)
	- {:ok, _} = :socket.bind(uds, %{family: :local, path: socket_path})
	- :ok = :socket.listen(uds)
	- uds
	- end
	+ defp start_process(%{args: %{cmd_with_args: cmd_with_args, cd: cd, env: env}} = state) do
	+ path = socket_path()
	+ {:ok, sock} = :socket.open(:local, :stream, :default)

	- @socket_timeout 2000
	- defp receive_file_descriptors!(uds) do
	- with {:ok, sock} <- :socket.accept(uds, @socket_timeout),
	- {:ok, msg} <- :socket.recvmsg(sock) do
	- %{
	- ctrl: [
	- %{
	- data: <<read_fd_int::native-32, write_fd_int::native-32, _rest::binary>>,
	- level: :socket,
	- type: :rights
	- }
	- ]
	- } = msg
	+ try do
	+ {:ok, _} = :socket.bind(sock, %{family: :local, path: path})
	+ :ok = :socket.listen(sock)
	+
	+ port = exec(cmd_with_args, path, env, cd)
	+ {:os_pid, os_pid} = Port.info(port, :os_pid)
	+ Exile.Watcher.watch(self(), os_pid, path)

	+ {stdout, stdin} = receive_fds(sock)
	+
	+ %Process{
	+ state
	+ \| port: port,
	+ status: :start,
	+ socket_path: path,
	+ stdin: stdin,
	+ stdout: stdout
	+ }
	+ after
	:socket.close(sock)
	+ end
	+ end

	- with {:ok, write_fd} <- Nif.nif_create_fd(write_fd_int),
	- {:ok, read_fd} <- Nif.nif_create_fd(read_fd_int) do
	- {write_fd, read_fd}
	- else
	- error ->
	+ @socket_timeout 2000
	+ defp receive_fds(lsock) do
	+ {:ok, sock} = :socket.accept(lsock, @socket_timeout)
	+
	+ try do
	+ case :socket.recvmsg(sock, @socket_timeout) do
	+ {:ok, msg} ->
	+ %{
	+ ctrl: [
	+ %{
	+ data: <<stdin_fd_int::native-32, stdout_fd_int::native-32, _::binary>>,
	+ level: :socket,
	+ type: :rights
	+ }
	+ ]
	+ } = msg
	+
	+ with {:ok, stdout} <- Nif.nif_create_fd(stdout_fd_int),
	+ {:ok, stdin} <- Nif.nif_create_fd(stdin_fd_int) do
	+ {stdout, stdin}
	+ else
	+ error ->
	+ raise Error,
	+ message: "Failed to create fd resources\n error: #{inspect(error)}"
	+ end
	+
	+ {:error, reason} ->
	raise Error,
	- message: "Failed to create fd resources\n error: #{inspect(error)}"
	+ message:
	+ "Failed to receive stdin and stdout file descriptors\n error: #{inspect(reason)}"
	end
	- else
	- error ->
	- raise Error,
	- message:
	- "Failed to receive stdin and stdout file descriptors\n error: #{inspect(error)}"
	+ after
	+ :socket.close(sock)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 28, 9:44 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 41018
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions