146 lines
4.5 KiB
Elixir
146 lines
4.5 KiB
Elixir
defmodule BDS.Publishing do
|
|
@moduledoc false
|
|
|
|
use GenServer
|
|
|
|
alias BDS.Projects
|
|
alias BDS.Tasks
|
|
|
|
def start_link(_opts) do
|
|
GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
|
|
end
|
|
|
|
def upload_site(project_id, credentials, opts \\ []) when is_binary(project_id) and is_map(credentials) and is_list(opts) do
|
|
project = Projects.get_project!(project_id)
|
|
normalized_credentials = normalize_credentials(credentials)
|
|
targets = build_upload_targets(Projects.project_data_dir(project), normalized_credentials)
|
|
GenServer.call(__MODULE__, {:upload_site, project_id, normalized_credentials, targets, opts})
|
|
end
|
|
|
|
def get_job(job_id) when is_binary(job_id) do
|
|
GenServer.call(__MODULE__, {:get_job, job_id})
|
|
end
|
|
|
|
@impl true
|
|
def init(_state) do
|
|
{:ok, %{jobs: %{}}}
|
|
end
|
|
|
|
@impl true
|
|
def handle_call({:get_job, job_id}, _from, state) do
|
|
{:reply, state.jobs[job_id], state}
|
|
end
|
|
|
|
def handle_call({:update_job, job_id, attrs}, _from, state) do
|
|
next_state =
|
|
update_in(state, [:jobs, job_id], fn
|
|
nil -> nil
|
|
job -> Map.merge(job, Map.put(attrs, :updated_at, DateTime.utc_now()))
|
|
end)
|
|
|
|
{:reply, :ok, next_state}
|
|
end
|
|
|
|
def handle_call({:upload_site, project_id, credentials, targets, opts}, _from, state) do
|
|
job_id = "publish-" <> Integer.to_string(System.unique_integer([:positive, :monotonic]))
|
|
uploader = Keyword.get(opts, :uploader, fn _target, _files, _credentials -> :ok end)
|
|
|
|
job = %{
|
|
id: job_id,
|
|
project_id: project_id,
|
|
status: :pending,
|
|
task_id: nil,
|
|
ssh_mode: credentials.ssh_mode,
|
|
targets: Enum.map(targets, & &1.kind),
|
|
error: nil,
|
|
inserted_at: DateTime.utc_now(),
|
|
updated_at: DateTime.utc_now()
|
|
}
|
|
|
|
{:ok, task} =
|
|
Tasks.submit_task("publish #{project_id}", fn report ->
|
|
run_upload(job_id, credentials, targets, uploader, report)
|
|
end, %{
|
|
group_id: project_id,
|
|
group_name: "Publishing"
|
|
})
|
|
|
|
next_job = %{job | task_id: task.id}
|
|
{:reply, {:ok, next_job}, put_in(state, [:jobs, job_id], next_job)}
|
|
end
|
|
|
|
defp run_upload(job_id, credentials, targets, uploader, report) do
|
|
update_job(job_id, %{status: :running, error: nil})
|
|
|
|
result =
|
|
Enum.with_index(targets, 1)
|
|
|> Enum.reduce_while(:ok, fn {target, index}, :ok ->
|
|
files = list_target_files(target)
|
|
report.(index / max(length(targets), 1), "Uploading #{target.kind}")
|
|
|
|
case uploader.(target, files, credentials) do
|
|
:ok -> {:cont, :ok}
|
|
{:error, reason} -> {:halt, {:error, reason}}
|
|
end
|
|
end)
|
|
|
|
case result do
|
|
:ok ->
|
|
update_job(job_id, %{status: :completed, error: nil})
|
|
{:ok, Enum.map(targets, & &1.kind)}
|
|
|
|
{:error, reason} ->
|
|
update_job(job_id, %{status: :failed, error: to_string(reason)})
|
|
{:error, to_string(reason)}
|
|
end
|
|
end
|
|
|
|
defp update_job(job_id, attrs) do
|
|
GenServer.call(__MODULE__, {:update_job, job_id, attrs})
|
|
end
|
|
|
|
defp build_upload_targets(base_dir, credentials) do
|
|
remote_root = String.trim_trailing(credentials.ssh_remote_path, "/")
|
|
|
|
[
|
|
%{kind: :html, local_dir: Path.join(base_dir, "html"), remote_dir: remote_root},
|
|
%{kind: :thumbnails, local_dir: Path.join(base_dir, "thumbnails"), remote_dir: Path.join(remote_root, "thumbnails")},
|
|
%{kind: :media, local_dir: Path.join(base_dir, "media"), remote_dir: Path.join(remote_root, "media")}
|
|
]
|
|
end
|
|
|
|
defp list_target_files(target) do
|
|
if File.dir?(target.local_dir) do
|
|
target.local_dir
|
|
|> Path.join("**/*")
|
|
|> Path.wildcard(match_dot: true)
|
|
|> Enum.filter(&File.regular?/1)
|
|
|> Enum.map(&Path.relative_to(&1, target.local_dir))
|
|
|> Enum.reject(fn relative_path -> target.kind == :media and String.ends_with?(relative_path, ".meta") end)
|
|
|> Enum.sort()
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
defp normalize_credentials(credentials) do
|
|
%{
|
|
ssh_host: attr(credentials, :ssh_host),
|
|
ssh_user: attr(credentials, :ssh_user),
|
|
ssh_remote_path: attr(credentials, :ssh_remote_path) || "/",
|
|
ssh_mode: normalize_ssh_mode(attr(credentials, :ssh_mode))
|
|
}
|
|
end
|
|
|
|
defp normalize_ssh_mode(mode) when mode in [:scp, :rsync], do: mode
|
|
defp normalize_ssh_mode("rsync"), do: :rsync
|
|
defp normalize_ssh_mode(_mode), do: :scp
|
|
|
|
defp attr(attrs, key) do
|
|
cond do
|
|
Map.has_key?(attrs, key) -> Map.get(attrs, key)
|
|
Map.has_key?(attrs, Atom.to_string(key)) -> Map.get(attrs, Atom.to_string(key))
|
|
true -> nil
|
|
end
|
|
end
|
|
end |