Current section
Files
Jump to
Current section
Files
src/gftp@actor.erl
-module(gftp@actor).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gftp/actor.gleam").
-export([with_call_timeout/2, welcome_message/1, with_mode/2, with_nat_workaround/2, with_active_mode/2, with_passive_stream_builder/2, into_secure/2, clear_command_channel/1, login/3, noop/1, pwd/1, cwd/2, cdup/1, mkd/2, rmd/2, dele/2, rename/3, transfer_type/2, rest/2, abor/1, mdtm/2, size/2, feat/1, opts/3, site/2, eprt/4, custom_command/3, mlst/2, retr/3, stor/3, appe/3, list/2, nlst/2, mlsd/2, custom_data_command/4, open_retr/2, open_stor/2, open_appe/2, open_list/2, open_nlst/2, open_mlsd/2, open_data_command/3, close_data_channel/2, quit/1, start/1]).
-export_type([state/0, handle/0, message/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(
" OTP actor wrapper for gftp that serializes all FTP operations.\n"
"\n"
" Wrapping an `FtpClient` in an actor prevents protocol state corruption\n"
" by ensuring that control commands are rejected while a data channel is open.\n"
"\n"
" ## Usage\n"
"\n"
" ```gleam\n"
" import gftp\n"
" import gftp/actor as ftp_actor\n"
"\n"
" let assert Ok(client) = gftp.connect(\"ftp.example.com\", 21)\n"
" let assert Ok(started) = ftp_actor.start(client)\n"
" let handle = started.data\n"
"\n"
" let assert Ok(_) = ftp_actor.login(handle, \"user\", \"password\")\n"
" let assert Ok(cwd) = ftp_actor.pwd(handle)\n"
" let assert Ok(_) = ftp_actor.quit(handle)\n"
" ```\n"
"\n"
" ## Message-based streaming\n"
"\n"
" The actor enforces chunk protection: once a data channel is opened via\n"
" `open_retr`, `open_stor`, etc., all control commands return\n"
" `Error(DataTransferInProgress)` until `close_data_channel` is called.\n"
"\n"
" ```gleam\n"
" let assert Ok(data_stream) = ftp_actor.open_retr(handle, \"file.txt\")\n"
" // ... receive data via stream.receive_next_packet_as_message ...\n"
" let assert Ok(_) = ftp_actor.close_data_channel(handle, data_stream)\n"
" ```\n"
).
-type state() :: {state, gftp:ftp_client(), boolean()}.
-opaque handle() :: {handle, gleam@erlang@process:subject(message()), integer()}.
-opaque message() :: {welcome_message,
gleam@erlang@process:subject(gleam@option:option(binary()))} |
{with_mode, gftp@mode:mode(), gleam@erlang@process:subject(nil)} |
{with_nat_workaround, boolean(), gleam@erlang@process:subject(nil)} |
{with_active_mode, integer(), gleam@erlang@process:subject(nil)} |
{with_passive_stream_builder,
fun((binary(), integer()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}),
gleam@erlang@process:subject(nil)} |
{into_secure,
kafein:wrap_options(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{clear_command_channel,
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{login,
binary(),
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{noop,
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{pwd,
gleam@erlang@process:subject({ok, binary()} |
{error, gftp@result:ftp_error()})} |
{cwd,
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{cdup,
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{mkd,
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{rmd,
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{dele,
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{rename,
binary(),
binary(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{transfer_type,
gftp@file_type:file_type(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{rest,
integer(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{abor,
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{mdtm,
binary(),
gleam@erlang@process:subject({ok, gleam@time@timestamp:timestamp()} |
{error, gftp@result:ftp_error()})} |
{size,
binary(),
gleam@erlang@process:subject({ok, integer()} |
{error, gftp@result:ftp_error()})} |
{feat,
gleam@erlang@process:subject({ok,
gleam@dict:dict(binary(), gleam@option:option(binary()))} |
{error, gftp@result:ftp_error()})} |
{opts,
binary(),
gleam@option:option(binary()),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{site_cmd,
binary(),
gleam@erlang@process:subject({ok, gftp@response:response()} |
{error, gftp@result:ftp_error()})} |
{eprt,
binary(),
integer(),
gftp@mode:ip_version(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{custom_command,
binary(),
list(gftp@status:status()),
gleam@erlang@process:subject({ok, gftp@response:response()} |
{error, gftp@result:ftp_error()})} |
{mlst,
gleam@option:option(binary()),
gleam@erlang@process:subject({ok, binary()} |
{error, gftp@result:ftp_error()})} |
{retr,
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()}),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{stor,
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()}),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{appe,
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()}),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{list_dir,
gleam@option:option(binary()),
gleam@erlang@process:subject({ok, list(binary())} |
{error, gftp@result:ftp_error()})} |
{nlst,
gleam@option:option(binary()),
gleam@erlang@process:subject({ok, list(binary())} |
{error, gftp@result:ftp_error()})} |
{mlsd,
gleam@option:option(binary()),
gleam@erlang@process:subject({ok, list(binary())} |
{error, gftp@result:ftp_error()})} |
{custom_data_command,
binary(),
list(gftp@status:status()),
fun((gftp@stream:data_stream(), gftp@response:response()) -> {ok, nil} |
{error, gftp@result:ftp_error()}),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{open_retr,
binary(),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_stor,
binary(),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_appe,
binary(),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_list,
gleam@option:option(binary()),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_nlst,
gleam@option:option(binary()),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_mlsd,
gleam@option:option(binary()),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})} |
{open_data_command,
binary(),
list(gftp@status:status()),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok,
{gftp@stream:data_stream(), gftp@response:response()}} |
{error, gftp@result:ftp_error()})} |
{close_data_channel,
gftp@stream:data_stream(),
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})} |
{quit,
gleam@erlang@process:subject({ok, nil} |
{error, gftp@result:ftp_error()})}.
-file("src/gftp/actor.gleam", 217).
?DOC(
" Set the timeout in milliseconds for actor calls. Defaults to 30000 (30 seconds).\n"
"\n"
" This timeout applies to all subsequent calls made through this handle.\n"
" For large file transfers via callback-based methods (`retr`, `stor`, `appe`),\n"
" consider increasing this value since the actor call blocks until the callback completes.\n"
"\n"
" ```gleam\n"
" let handle = ftp_actor.with_call_timeout(handle, 120_000)\n"
" ```\n"
).
-spec with_call_timeout(handle(), integer()) -> handle().
with_call_timeout(Handle, Timeout) ->
{handle, erlang:element(2, Handle), Timeout}.
-file("src/gftp/actor.gleam", 224).
?DOC(" Get the welcome message from the FTP server.\n").
-spec welcome_message(handle()) -> gleam@option:option(binary()).
welcome_message(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {welcome_message, Field@0} end
).
-file("src/gftp/actor.gleam", 229).
?DOC(" Set the data transfer mode.\n").
-spec with_mode(handle(), gftp@mode:mode()) -> nil.
with_mode(Handle, Mode) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {with_mode, Mode, _capture} end
).
-file("src/gftp/actor.gleam", 234).
?DOC(" Enable or disable the NAT workaround for passive mode.\n").
-spec with_nat_workaround(handle(), boolean()) -> nil.
with_nat_workaround(Handle, Enabled) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {with_nat_workaround, Enabled, _capture} end
).
-file("src/gftp/actor.gleam", 239).
?DOC(" Enable active mode with the specified data connection timeout.\n").
-spec with_active_mode(handle(), integer()) -> nil.
with_active_mode(Handle, Timeout) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {with_active_mode, Timeout, _capture} end
).
-file("src/gftp/actor.gleam", 244).
?DOC(" Set a custom passive stream builder.\n").
-spec with_passive_stream_builder(
handle(),
fun((binary(), integer()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})
) -> nil.
with_passive_stream_builder(Handle, Builder) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {with_passive_stream_builder, Builder, _capture} end
).
-file("src/gftp/actor.gleam", 257).
?DOC(" Switch to explicit secure mode (FTPS).\n").
-spec into_secure(handle(), kafein:wrap_options()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
into_secure(Handle, Ssl_options) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {into_secure, Ssl_options, _capture} end
).
-file("src/gftp/actor.gleam", 265).
?DOC(" Clear the command channel encryption.\n").
-spec clear_command_channel(handle()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
clear_command_channel(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {clear_command_channel, Field@0} end
).
-file("src/gftp/actor.gleam", 272).
?DOC(" Log in to the FTP server.\n").
-spec login(handle(), binary(), binary()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
login(Handle, Username, Password) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {login, Username, Password, _capture} end
).
-file("src/gftp/actor.gleam", 281).
?DOC(" Send a NOOP command.\n").
-spec noop(handle()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
noop(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {noop, Field@0} end
).
-file("src/gftp/actor.gleam", 286).
?DOC(" Get the current working directory.\n").
-spec pwd(handle()) -> {ok, binary()} | {error, gftp@result:ftp_error()}.
pwd(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {pwd, Field@0} end
).
-file("src/gftp/actor.gleam", 291).
?DOC(" Change working directory.\n").
-spec cwd(handle(), binary()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
cwd(Handle, Path) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {cwd, Path, _capture} end
).
-file("src/gftp/actor.gleam", 296).
?DOC(" Change to parent directory.\n").
-spec cdup(handle()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
cdup(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {cdup, Field@0} end
).
-file("src/gftp/actor.gleam", 301).
?DOC(" Create a directory.\n").
-spec mkd(handle(), binary()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
mkd(Handle, Path) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {mkd, Path, _capture} end
).
-file("src/gftp/actor.gleam", 306).
?DOC(" Remove a directory.\n").
-spec rmd(handle(), binary()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
rmd(Handle, Path) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {rmd, Path, _capture} end
).
-file("src/gftp/actor.gleam", 311).
?DOC(" Delete a file.\n").
-spec dele(handle(), binary()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
dele(Handle, Path) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {dele, Path, _capture} end
).
-file("src/gftp/actor.gleam", 316).
?DOC(" Rename a file.\n").
-spec rename(handle(), binary(), binary()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
rename(Handle, From, To) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {rename, From, To, _capture} end
).
-file("src/gftp/actor.gleam", 321).
?DOC(" Set the file transfer type.\n").
-spec transfer_type(handle(), gftp@file_type:file_type()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
transfer_type(Handle, File_type) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {transfer_type, File_type, _capture} end
).
-file("src/gftp/actor.gleam", 329).
?DOC(" Set the restart offset for the next transfer.\n").
-spec rest(handle(), integer()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
rest(Handle, Offset) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {rest, Offset, _capture} end
).
-file("src/gftp/actor.gleam", 334).
?DOC(" Abort an active file transfer.\n").
-spec abor(handle()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
abor(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {abor, Field@0} end
).
-file("src/gftp/actor.gleam", 339).
?DOC(" Get the modification time of a file.\n").
-spec mdtm(handle(), binary()) -> {ok, gleam@time@timestamp:timestamp()} |
{error, gftp@result:ftp_error()}.
mdtm(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {mdtm, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 344).
?DOC(" Get the size of a file in bytes.\n").
-spec size(handle(), binary()) -> {ok, integer()} |
{error, gftp@result:ftp_error()}.
size(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {size, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 349).
?DOC(" Retrieve server features (FEAT command).\n").
-spec feat(handle()) -> {ok,
gleam@dict:dict(binary(), gleam@option:option(binary()))} |
{error, gftp@result:ftp_error()}.
feat(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {feat, Field@0} end
).
-file("src/gftp/actor.gleam", 354).
?DOC(" Set a server option (OPTS command).\n").
-spec opts(handle(), binary(), gleam@option:option(binary())) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
opts(Handle, Option, Value) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {opts, Option, Value, _capture} end
).
-file("src/gftp/actor.gleam", 363).
?DOC(" Execute a SITE command.\n").
-spec site(handle(), binary()) -> {ok, gftp@response:response()} |
{error, gftp@result:ftp_error()}.
site(Handle, Sub_command) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {site_cmd, Sub_command, _capture} end
).
-file("src/gftp/actor.gleam", 368).
?DOC(" Execute an EPRT command.\n").
-spec eprt(handle(), binary(), integer(), gftp@mode:ip_version()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
eprt(Handle, Address, Port, Ip_version) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {eprt, Address, Port, Ip_version, _capture} end
).
-file("src/gftp/actor.gleam", 383).
?DOC(" Execute a custom FTP command.\n").
-spec custom_command(handle(), binary(), list(gftp@status:status())) -> {ok,
gftp@response:response()} |
{error, gftp@result:ftp_error()}.
custom_command(Handle, Command_str, Expected_statuses) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) ->
{custom_command, Command_str, Expected_statuses, _capture}
end
).
-file("src/gftp/actor.gleam", 396).
?DOC(" Execute an MLST command.\n").
-spec mlst(handle(), gleam@option:option(binary())) -> {ok, binary()} |
{error, gftp@result:ftp_error()}.
mlst(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {mlst, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 403).
?DOC(" Download a file using a callback.\n").
-spec retr(
handle(),
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()})
) -> {ok, nil} | {error, gftp@result:ftp_error()}.
retr(Handle, Path, Reader) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {retr, Path, Reader, _capture} end
).
-file("src/gftp/actor.gleam", 412).
?DOC(" Upload a file using a callback.\n").
-spec stor(
handle(),
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()})
) -> {ok, nil} | {error, gftp@result:ftp_error()}.
stor(Handle, Path, Writer) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {stor, Path, Writer, _capture} end
).
-file("src/gftp/actor.gleam", 421).
?DOC(" Append to a file using a callback.\n").
-spec appe(
handle(),
binary(),
fun((gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()})
) -> {ok, nil} | {error, gftp@result:ftp_error()}.
appe(Handle, Path, Writer) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {appe, Path, Writer, _capture} end
).
-file("src/gftp/actor.gleam", 430).
?DOC(" List directory contents.\n").
-spec list(handle(), gleam@option:option(binary())) -> {ok, list(binary())} |
{error, gftp@result:ftp_error()}.
list(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {list_dir, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 435).
?DOC(" List file names only.\n").
-spec nlst(handle(), gleam@option:option(binary())) -> {ok, list(binary())} |
{error, gftp@result:ftp_error()}.
nlst(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {nlst, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 440).
?DOC(" Machine-readable directory listing.\n").
-spec mlsd(handle(), gleam@option:option(binary())) -> {ok, list(binary())} |
{error, gftp@result:ftp_error()}.
mlsd(Handle, Pathname) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {mlsd, Pathname, _capture} end
).
-file("src/gftp/actor.gleam", 445).
?DOC(" Execute a custom data command with a callback.\n").
-spec custom_data_command(
handle(),
binary(),
list(gftp@status:status()),
fun((gftp@stream:data_stream(), gftp@response:response()) -> {ok, nil} |
{error, gftp@result:ftp_error()})
) -> {ok, nil} | {error, gftp@result:ftp_error()}.
custom_data_command(Handle, Command_str, Expected_statuses, On_data_stream) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) ->
{custom_data_command,
Command_str,
Expected_statuses,
On_data_stream,
_capture}
end
).
-file("src/gftp/actor.gleam", 465).
?DOC(
" Open a data channel for downloading a file.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_retr(handle(), binary()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_retr(Handle, Path) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_retr, Path, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 474).
?DOC(
" Open a data channel for uploading a file.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_stor(handle(), binary()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_stor(Handle, Path) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_stor, Path, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 483).
?DOC(
" Open a data channel for appending to a file.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_appe(handle(), binary()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_appe(Handle, Path) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_appe, Path, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 492).
?DOC(
" Open a data channel for a LIST directory listing.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_list(handle(), gleam@option:option(binary())) -> {ok,
gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_list(Handle, Pathname) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_list, Pathname, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 504).
?DOC(
" Open a data channel for an NLST file name listing.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_nlst(handle(), gleam@option:option(binary())) -> {ok,
gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_nlst(Handle, Pathname) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_nlst, Pathname, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 516).
?DOC(
" Open a data channel for an MLSD machine-readable listing.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_mlsd(handle(), gleam@option:option(binary())) -> {ok,
gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}.
open_mlsd(Handle, Pathname) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {open_mlsd, Pathname, Caller, _capture} end
).
-file("src/gftp/actor.gleam", 528).
?DOC(
" Open a data channel for a custom command.\n"
"\n"
" The returned `DataStream` has its controlling process set to the caller,\n"
" so message-based I/O (`receive_next_packet_as_message`) works correctly.\n"
).
-spec open_data_command(handle(), binary(), list(gftp@status:status())) -> {ok,
{gftp@stream:data_stream(), gftp@response:response()}} |
{error, gftp@result:ftp_error()}.
open_data_command(Handle, Command_str, Expected_statuses) ->
Caller = erlang:self(),
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) ->
{open_data_command,
Command_str,
Expected_statuses,
Caller,
_capture}
end
).
-file("src/gftp/actor.gleam", 543).
?DOC(" Close a data channel and finalize the transfer.\n").
-spec close_data_channel(handle(), gftp@stream:data_stream()) -> {ok, nil} |
{error, gftp@result:ftp_error()}.
close_data_channel(Handle, Data_stream) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(_capture) -> {close_data_channel, Data_stream, _capture} end
).
-file("src/gftp/actor.gleam", 556).
?DOC(" Quit the FTP session and stop the actor.\n").
-spec quit(handle()) -> {ok, nil} | {error, gftp@result:ftp_error()}.
quit(Handle) ->
gleam@otp@actor:call(
erlang:element(2, Handle),
erlang:element(3, Handle),
fun(Field@0) -> {quit, Field@0} end
).
-file("src/gftp/actor.gleam", 745).
?DOC(
" Guard against issuing control commands while a data channel is open.\n"
" If `chunk` is `True`, replies with `DataTransferInProgress` and continues.\n"
" Otherwise, runs the operation and continues with the (possibly updated) state.\n"
).
-spec guard_chunk(
state(),
gleam@erlang@process:subject({ok, LLI} | {error, gftp@result:ftp_error()}),
fun((state()) -> {state(), {ok, LLI} | {error, gftp@result:ftp_error()}})
) -> gleam@otp@actor:next(state(), message()).
guard_chunk(State, Reply, Operation) ->
case erlang:element(3, State) of
true ->
gleam@erlang@process:send(Reply, {error, data_transfer_in_progress}),
gleam@otp@actor:continue(State);
false ->
{New_state, Result} = Operation(State),
gleam@erlang@process:send(Reply, Result),
gleam@otp@actor:continue(New_state)
end.
-file("src/gftp/actor.gleam", 765).
?DOC(
" Guard for open_* commands that return a `DataStream`.\n"
" On success, sets `chunk = True` and transfers socket ownership to the caller.\n"
).
-spec guard_chunk_open(
state(),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()}),
fun((state()) -> {ok, gftp@stream:data_stream()} |
{error, gftp@result:ftp_error()})
) -> gleam@otp@actor:next(state(), message()).
guard_chunk_open(State, Caller, Reply, Operation) ->
case erlang:element(3, State) of
true ->
gleam@erlang@process:send(Reply, {error, data_transfer_in_progress}),
gleam@otp@actor:continue(State);
false ->
Result = Operation(State),
{New_chunk, Final_result} = case Result of
{ok, Ds} ->
case gftp@stream:controlling_process(Ds, Caller) of
{ok, _} ->
{true, {ok, Ds}};
{error, E} ->
{false, {error, {socket, E}}}
end;
{error, E@1} ->
{false, {error, E@1}}
end,
gleam@erlang@process:send(Reply, Final_result),
gleam@otp@actor:continue(
{state, erlang:element(2, State), New_chunk}
)
end.
-file("src/gftp/actor.gleam", 794).
?DOC(
" Guard for open_data_command which returns a `#(DataStream, Response)`.\n"
" On success, sets `chunk = True` and transfers socket ownership to the caller.\n"
).
-spec guard_chunk_open_pair(
state(),
gleam@erlang@process:pid_(),
gleam@erlang@process:subject({ok,
{gftp@stream:data_stream(), gftp@response:response()}} |
{error, gftp@result:ftp_error()}),
fun((state()) -> {ok, {gftp@stream:data_stream(), gftp@response:response()}} |
{error, gftp@result:ftp_error()})
) -> gleam@otp@actor:next(state(), message()).
guard_chunk_open_pair(State, Caller, Reply, Operation) ->
case erlang:element(3, State) of
true ->
gleam@erlang@process:send(Reply, {error, data_transfer_in_progress}),
gleam@otp@actor:continue(State);
false ->
Result = Operation(State),
{New_chunk, Final_result} = case Result of
{ok, {Ds, Resp}} ->
case gftp@stream:controlling_process(Ds, Caller) of
{ok, _} ->
{true, {ok, {Ds, Resp}}};
{error, E} ->
{false, {error, {socket, E}}}
end;
{error, E@1} ->
{false, {error, E@1}}
end,
gleam@erlang@process:send(Reply, Final_result),
gleam@otp@actor:continue(
{state, erlang:element(2, State), New_chunk}
)
end.
-file("src/gftp/actor.gleam", 564).
-spec handle_message(state(), message()) -> gleam@otp@actor:next(state(), message()).
handle_message(State, Message) ->
case Message of
{welcome_message, Reply} ->
gleam@erlang@process:send(
Reply,
gftp:welcome_message(erlang:element(2, State))
),
gleam@otp@actor:continue(State);
{with_mode, Mode, Reply@1} ->
Client = gftp:with_mode(erlang:element(2, State), Mode),
gleam@erlang@process:send(Reply@1, nil),
gleam@otp@actor:continue({state, Client, erlang:element(3, State)});
{with_nat_workaround, Enabled, Reply@2} ->
Client@1 = gftp:with_nat_workaround(
erlang:element(2, State),
Enabled
),
gleam@erlang@process:send(Reply@2, nil),
gleam@otp@actor:continue(
{state, Client@1, erlang:element(3, State)}
);
{with_active_mode, Timeout, Reply@3} ->
Client@2 = gftp:with_active_mode(erlang:element(2, State), Timeout),
gleam@erlang@process:send(Reply@3, nil),
gleam@otp@actor:continue(
{state, Client@2, erlang:element(3, State)}
);
{with_passive_stream_builder, Builder, Reply@4} ->
Client@3 = gftp:with_passive_stream_builder(
erlang:element(2, State),
Builder
),
gleam@erlang@process:send(Reply@4, nil),
gleam@otp@actor:continue(
{state, Client@3, erlang:element(3, State)}
);
{into_secure, Ssl_options, Reply@5} ->
guard_chunk(
State,
Reply@5,
fun(S) ->
case gftp:into_secure(erlang:element(2, S), Ssl_options) of
{ok, New_client} ->
{{state, New_client, erlang:element(3, S)},
{ok, nil}};
{error, E} ->
{S, {error, E}}
end
end
);
{clear_command_channel, Reply@6} ->
guard_chunk(
State,
Reply@6,
fun(S@1) ->
case gftp:clear_command_channel(erlang:element(2, S@1)) of
{ok, New_client@1} ->
{{state, New_client@1, erlang:element(3, S@1)},
{ok, nil}};
{error, E@1} ->
{S@1, {error, E@1}}
end
end
);
{login, Username, Password, Reply@7} ->
guard_chunk(
State,
Reply@7,
fun(S@2) ->
{S@2,
gftp:login(erlang:element(2, S@2), Username, Password)}
end
);
{noop, Reply@8} ->
guard_chunk(
State,
Reply@8,
fun(S@3) -> {S@3, gftp:noop(erlang:element(2, S@3))} end
);
{pwd, Reply@9} ->
guard_chunk(
State,
Reply@9,
fun(S@4) -> {S@4, gftp:pwd(erlang:element(2, S@4))} end
);
{cwd, Path, Reply@10} ->
guard_chunk(
State,
Reply@10,
fun(S@5) -> {S@5, gftp:cwd(erlang:element(2, S@5), Path)} end
);
{cdup, Reply@11} ->
guard_chunk(
State,
Reply@11,
fun(S@6) -> {S@6, gftp:cdup(erlang:element(2, S@6))} end
);
{mkd, Path@1, Reply@12} ->
guard_chunk(
State,
Reply@12,
fun(S@7) -> {S@7, gftp:mkd(erlang:element(2, S@7), Path@1)} end
);
{rmd, Path@2, Reply@13} ->
guard_chunk(
State,
Reply@13,
fun(S@8) -> {S@8, gftp:rmd(erlang:element(2, S@8), Path@2)} end
);
{dele, Path@3, Reply@14} ->
guard_chunk(
State,
Reply@14,
fun(S@9) -> {S@9, gftp:dele(erlang:element(2, S@9), Path@3)} end
);
{rename, From, To, Reply@15} ->
guard_chunk(
State,
Reply@15,
fun(S@10) ->
{S@10, gftp:rename(erlang:element(2, S@10), From, To)}
end
);
{transfer_type, File_type, Reply@16} ->
guard_chunk(
State,
Reply@16,
fun(S@11) ->
{S@11,
gftp:transfer_type(erlang:element(2, S@11), File_type)}
end
);
{rest, Offset, Reply@17} ->
guard_chunk(
State,
Reply@17,
fun(S@12) ->
{S@12, gftp:rest(erlang:element(2, S@12), Offset)}
end
);
{abor, Reply@18} ->
guard_chunk(
State,
Reply@18,
fun(S@13) -> {S@13, gftp:abor(erlang:element(2, S@13))} end
);
{mdtm, Pathname, Reply@19} ->
guard_chunk(
State,
Reply@19,
fun(S@14) ->
{S@14, gftp:mdtm(erlang:element(2, S@14), Pathname)}
end
);
{size, Pathname@1, Reply@20} ->
guard_chunk(
State,
Reply@20,
fun(S@15) ->
{S@15, gftp:size(erlang:element(2, S@15), Pathname@1)}
end
);
{feat, Reply@21} ->
guard_chunk(
State,
Reply@21,
fun(S@16) -> {S@16, gftp:feat(erlang:element(2, S@16))} end
);
{opts, Option, Value, Reply@22} ->
guard_chunk(
State,
Reply@22,
fun(S@17) ->
{S@17, gftp:opts(erlang:element(2, S@17), Option, Value)}
end
);
{site_cmd, Sub_command, Reply@23} ->
guard_chunk(
State,
Reply@23,
fun(S@18) ->
{S@18, gftp:site(erlang:element(2, S@18), Sub_command)}
end
);
{eprt, Address, Port, Ip_version, Reply@24} ->
guard_chunk(
State,
Reply@24,
fun(S@19) ->
{S@19,
gftp:eprt(
erlang:element(2, S@19),
Address,
Port,
Ip_version
)}
end
);
{custom_command, Command_str, Expected_statuses, Reply@25} ->
guard_chunk(
State,
Reply@25,
fun(S@20) ->
{S@20,
gftp:custom_command(
erlang:element(2, S@20),
Command_str,
Expected_statuses
)}
end
);
{mlst, Pathname@2, Reply@26} ->
guard_chunk(
State,
Reply@26,
fun(S@21) ->
{S@21, gftp:mlst(erlang:element(2, S@21), Pathname@2)}
end
);
{retr, Path@4, Reader, Reply@27} ->
guard_chunk(
State,
Reply@27,
fun(S@22) ->
{S@22, gftp:retr(erlang:element(2, S@22), Path@4, Reader)}
end
);
{stor, Path@5, Writer, Reply@28} ->
guard_chunk(
State,
Reply@28,
fun(S@23) ->
{S@23, gftp:stor(erlang:element(2, S@23), Path@5, Writer)}
end
);
{appe, Path@6, Writer@1, Reply@29} ->
guard_chunk(
State,
Reply@29,
fun(S@24) ->
{S@24, gftp:appe(erlang:element(2, S@24), Path@6, Writer@1)}
end
);
{list_dir, Pathname@3, Reply@30} ->
guard_chunk(
State,
Reply@30,
fun(S@25) ->
{S@25, gftp:list(erlang:element(2, S@25), Pathname@3)}
end
);
{nlst, Pathname@4, Reply@31} ->
guard_chunk(
State,
Reply@31,
fun(S@26) ->
{S@26, gftp:nlst(erlang:element(2, S@26), Pathname@4)}
end
);
{mlsd, Pathname@5, Reply@32} ->
guard_chunk(
State,
Reply@32,
fun(S@27) ->
{S@27, gftp:mlsd(erlang:element(2, S@27), Pathname@5)}
end
);
{custom_data_command,
Command_str@1,
Expected_statuses@1,
On_data_stream,
Reply@33} ->
guard_chunk(
State,
Reply@33,
fun(S@28) ->
{S@28,
gftp:custom_data_command(
erlang:element(2, S@28),
Command_str@1,
Expected_statuses@1,
On_data_stream
)}
end
);
{open_retr, Path@7, Caller, Reply@34} ->
guard_chunk_open(
State,
Caller,
Reply@34,
fun(S@29) ->
gftp@internal@data_channel:open_retr(
erlang:element(2, S@29),
Path@7
)
end
);
{open_stor, Path@8, Caller@1, Reply@35} ->
guard_chunk_open(
State,
Caller@1,
Reply@35,
fun(S@30) ->
gftp@internal@data_channel:open_stor(
erlang:element(2, S@30),
Path@8
)
end
);
{open_appe, Path@9, Caller@2, Reply@36} ->
guard_chunk_open(
State,
Caller@2,
Reply@36,
fun(S@31) ->
gftp@internal@data_channel:open_appe(
erlang:element(2, S@31),
Path@9
)
end
);
{open_list, Pathname@6, Caller@3, Reply@37} ->
guard_chunk_open(
State,
Caller@3,
Reply@37,
fun(S@32) ->
gftp@internal@data_channel:open_list(
erlang:element(2, S@32),
Pathname@6
)
end
);
{open_nlst, Pathname@7, Caller@4, Reply@38} ->
guard_chunk_open(
State,
Caller@4,
Reply@38,
fun(S@33) ->
gftp@internal@data_channel:open_nlst(
erlang:element(2, S@33),
Pathname@7
)
end
);
{open_mlsd, Pathname@8, Caller@5, Reply@39} ->
guard_chunk_open(
State,
Caller@5,
Reply@39,
fun(S@34) ->
gftp@internal@data_channel:open_mlsd(
erlang:element(2, S@34),
Pathname@8
)
end
);
{open_data_command,
Command_str@2,
Expected_statuses@2,
Caller@6,
Reply@40} ->
guard_chunk_open_pair(
State,
Caller@6,
Reply@40,
fun(S@35) ->
gftp@internal@data_channel:open_data_command(
erlang:element(2, S@35),
Command_str@2,
Expected_statuses@2
)
end
);
{close_data_channel, Data_stream, Reply@41} ->
Result = gftp@internal@data_channel:close_data_channel(
erlang:element(2, State),
Data_stream
),
gleam@erlang@process:send(Reply@41, Result),
gleam@otp@actor:continue({state, erlang:element(2, State), false});
{quit, Reply@42} ->
Result@1 = gftp:quit(erlang:element(2, State)),
_ = gftp:shutdown(erlang:element(2, State)),
gleam@erlang@process:send(Reply@42, Result@1),
gleam@otp@actor:stop()
end.
-file("src/gftp/actor.gleam", 193).
?DOC(
" Start an FTP actor wrapping the given client.\n"
"\n"
" The client should already be connected (via `gftp.connect`).\n"
" All subsequent operations should go through the returned `Handle`.\n"
" \n"
" You should never keep an active `FtpClient` around after starting the actor,\n"
" as it would allow bypassing the chunk protection and corrupting the protocol state.\n"
" Only interact with the FTP session via the returned `Handle` and the functions in this module.\n"
).
-spec start(gftp:ftp_client()) -> {ok, gleam@otp@actor:started(handle())} |
{error, gleam@otp@actor:start_error()}.
start(Client) ->
_pipe = {state, Client, false},
_pipe@1 = gleam@otp@actor:new(_pipe),
_pipe@2 = gleam@otp@actor:on_message(_pipe@1, fun handle_message/2),
_pipe@3 = gleam@otp@actor:start(_pipe@2),
gleam@result:map(
_pipe@3,
fun(Started) ->
{started,
erlang:element(2, Started),
{handle, erlang:element(3, Started), 30000}}
end
).