>, number, shift) when byte > 127 do
25 | byte = Bitwise.band(byte, 127)
26 | do_decode(rest, number + Bitwise.bsl(byte, shift), shift + 7)
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/lib/asciinema/media.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Media do
2 | alias Asciinema.{Accounts, Themes}
3 |
4 | def term_theme_name(medium) do
5 | cond do
6 | medium.term_theme_name -> medium.term_theme_name
7 | true -> Accounts.default_term_theme_name(medium.user) || "asciinema"
8 | end
9 | end
10 |
11 | def theme(%{term_theme_prefer_original: true, term_theme_palette: p} = medium)
12 | when not is_nil(p) do
13 | Themes.custom_theme(medium.term_theme_fg, medium.term_theme_bg, p)
14 | end
15 |
16 | def theme(medium) do
17 | case term_theme_name(medium) do
18 | "original" ->
19 | Themes.custom_theme(medium.term_theme_fg, medium.term_theme_bg, medium.term_theme_palette)
20 |
21 | name ->
22 | Themes.named_theme(name)
23 | end
24 | end
25 |
26 | def original_theme(%{term_theme_name: "original"} = medium) do
27 | Themes.custom_theme(medium.term_theme_fg, medium.term_theme_bg, medium.term_theme_palette)
28 | end
29 |
30 | def original_theme(_medium), do: nil
31 |
32 | def font_family(medium) do
33 | case medium.term_font_family || Accounts.default_font_family(medium.user) do
34 | "default" -> nil
35 | family -> family
36 | end
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/asciinema/oban_error_reporter.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.ObanErrorReporter do
2 | def configure do
3 | :telemetry.attach_many(
4 | "oban-errors",
5 | [[:oban, :job, :exception], [:oban, :circuit, :trip]],
6 | &__MODULE__.handle_event/4,
7 | %{}
8 | )
9 | end
10 |
11 | def handle_event([:oban, :job, :exception], measure, %{job: job} = meta, _) do
12 | extra =
13 | job
14 | |> Map.take([:id, :args, :meta, :queue, :worker])
15 | |> Map.merge(measure)
16 |
17 | Sentry.capture_exception(meta.error, stacktrace: meta.stacktrace, extra: extra)
18 | end
19 |
20 | def handle_event([:oban, :circuit, :trip], _measure, meta, _) do
21 | Sentry.capture_exception(meta.error, stacktrace: meta.stacktrace, extra: meta)
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/lib/asciinema/png_generator.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.PngGenerator do
2 | alias Asciinema.Recordings.Asciicast
3 |
4 | @doc "Generates PNG image from asciicast and returns path to it"
5 | @callback generate(asciicast :: %Asciicast{}) :: {:ok, String.t()} | {:error, term}
6 |
7 | def generate(asciicast) do
8 | Keyword.fetch!(Application.get_env(:asciinema, __MODULE__), :adapter).generate(asciicast)
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/lib/asciinema/pub_sub.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.PubSub do
2 | def subscribe(topic) do
3 | :ok = Phoenix.PubSub.subscribe(__MODULE__, topic)
4 | end
5 |
6 | def broadcast(topic, payload) do
7 | :ok = Phoenix.PubSub.broadcast(__MODULE__, topic, payload)
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/lib/asciinema/recordings/asciicast/v1.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Recordings.Asciicast.V1 do
2 | alias Asciinema.Recordings.EventStream
3 |
4 | def event_stream(path) when is_binary(path) do
5 | asciicast =
6 | path
7 | |> File.read!()
8 | |> Jason.decode!()
9 |
10 | 1 = asciicast["version"]
11 |
12 | asciicast
13 | |> Map.fetch!("stdout")
14 | |> Stream.map(fn [time, data] -> {time, "o", data} end)
15 | |> EventStream.to_absolute_time()
16 | end
17 |
18 | def fetch_metadata(path) do
19 | with {:ok, json} <- File.read(path),
20 | {:ok, %{"version" => 1} = attrs} <- Jason.decode(json) do
21 | metadata = %{
22 | version: 1,
23 | term_cols: attrs["width"],
24 | term_rows: attrs["height"],
25 | term_type: get_in(attrs, ["env", "TERM"]),
26 | command: attrs["command"],
27 | duration: attrs["duration"],
28 | title: attrs["title"],
29 | shell: get_in(attrs, ["env", "SHELL"]),
30 | env: attrs["env"] || %{}
31 | }
32 |
33 | {:ok, metadata}
34 | else
35 | {:ok, %{"version" => version}} ->
36 | {:error, {:invalid_version, version}}
37 |
38 | {:error, %Jason.DecodeError{}} ->
39 | {:error, :invalid_format}
40 | end
41 | end
42 | end
43 |
--------------------------------------------------------------------------------
/lib/asciinema/recordings/event_stream.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Recordings.EventStream do
2 | def to_absolute_time(stream) do
3 | Stream.scan(stream, &to_absolute_time/2)
4 | end
5 |
6 | defp to_absolute_time({curr_time, code, data}, {prev_time, _, _}) do
7 | {prev_time + curr_time, code, data}
8 | end
9 |
10 | def to_relative_time(stream) do
11 | Stream.transform(stream, 0, &to_relative_time/2)
12 | end
13 |
14 | defp to_relative_time({curr_time, code, data}, prev_time) do
15 | {[{curr_time - prev_time, code, data}], curr_time}
16 | end
17 |
18 | def cap_relative_time({_, _, _} = frame, nil) do
19 | frame
20 | end
21 |
22 | def cap_relative_time({time, code, data}, time_limit) do
23 | {min(time, time_limit), code, data}
24 | end
25 |
26 | def cap_relative_time(stream, time_limit) do
27 | Stream.map(stream, &cap_relative_time(&1, time_limit))
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/lib/asciinema/recordings/markers.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Recordings.Markers do
2 | def validate(_, markers) do
3 | case parse(markers) do
4 | {:ok, _} -> []
5 | {:error, index} -> [markers: "invalid syntax in line #{index + 1}"]
6 | end
7 | end
8 |
9 | def parse(markers) do
10 | results =
11 | markers
12 | |> String.trim()
13 | |> String.split("\n")
14 | |> Enum.map(&parse_one/1)
15 |
16 | case Enum.find_index(results, fn result -> result == :error end) do
17 | nil -> {:ok, results}
18 | index -> {:error, index}
19 | end
20 | end
21 |
22 | defp parse_one(marker) do
23 | parts =
24 | marker
25 | |> String.trim()
26 | |> String.split(~r/\s+-\s+/, parts: 2)
27 | |> Kernel.++([""])
28 | |> Enum.take(2)
29 |
30 | with [t, l] <- parts,
31 | {t, ""} <- Float.parse(t),
32 | true <- String.length(l) < 100 do
33 | {t, l}
34 | else
35 | _ -> :error
36 | end
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/asciinema/recordings/text.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Recordings.Text do
2 | alias Asciinema.Recordings
3 | alias Asciinema.Recordings.{Asciicast, Paths}
4 | alias Asciinema.{FileCache, Vt}
5 |
6 | def text(%Asciicast{term_cols: cols, term_rows: rows} = asciicast) do
7 | stream = Recordings.event_stream(asciicast)
8 |
9 | Vt.with_vt(cols, rows, [scrollback_limit: nil], fn vt ->
10 | Enum.each(stream, fn {_, code, data} ->
11 | case code do
12 | "o" ->
13 | Vt.feed(vt, data)
14 |
15 | "r" ->
16 | [cols, rows] = String.split(data, "x")
17 | cols = String.to_integer(cols)
18 | rows = String.to_integer(rows)
19 | Vt.resize(vt, cols, rows)
20 |
21 | _ ->
22 | :ok
23 | end
24 | end)
25 |
26 | Vt.text(vt)
27 | end)
28 | end
29 |
30 | def text_file_path(asciicast) do
31 | FileCache.full_path(
32 | :txt,
33 | Paths.path(asciicast, "txt"),
34 | fn -> text(asciicast) end
35 | )
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/asciinema/release.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Release do
2 | @moduledoc """
3 | Used for executing DB release tasks when run in production without Mix
4 | installed.
5 | """
6 | @app :asciinema
7 |
8 | def migrate do
9 | load_app()
10 |
11 | for repo <- repos() do
12 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
13 | end
14 | end
15 |
16 | def rollback(repo, version) do
17 | load_app()
18 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
19 | end
20 |
21 | def admin_add(emails) when is_binary(emails) do
22 | emails
23 | |> String.split(~r/[, ]+/)
24 | |> admin_add()
25 | end
26 |
27 | def admin_add(emails) when is_list(emails) do
28 | load_app()
29 |
30 | Ecto.Migrator.with_repo(Asciinema.Repo, fn _repo ->
31 | Asciinema.Accounts.add_admins(emails)
32 | IO.puts("#{Enum.join(emails, ", ")} added to admin users list")
33 | end)
34 | end
35 |
36 | def admin_rm(emails) when is_binary(emails) do
37 | emails
38 | |> String.split(~r/[, ]+/)
39 | |> admin_rm()
40 | end
41 |
42 | def admin_rm(emails) when is_list(emails) do
43 | load_app()
44 |
45 | Ecto.Migrator.with_repo(Asciinema.Repo, fn _repo ->
46 | Asciinema.Accounts.remove_admins(emails)
47 | IO.puts("#{Enum.join(emails, ", ")} removed from admin users list")
48 | end)
49 | end
50 |
51 | defp repos do
52 | Application.fetch_env!(@app, :ecto_repos)
53 | end
54 |
55 | defp load_app do
56 | Application.load(@app)
57 | Application.ensure_all_started(:ssl)
58 | end
59 | end
60 |
--------------------------------------------------------------------------------
/lib/asciinema/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Repo do
2 | use Ecto.Repo,
3 | otp_app: :asciinema,
4 | adapter: Ecto.Adapters.Postgres
5 |
6 | use Scrivener, page_size: 10
7 |
8 | def transact(fun, opts \\ []) do
9 | transaction(
10 | fn ->
11 | case fun.() do
12 | {:ok, value} -> value
13 | :ok -> :transaction_commited
14 | {:error, reason} -> rollback(reason)
15 | :error -> rollback(:transaction_rollback_error)
16 | end
17 | end,
18 | opts
19 | )
20 | end
21 |
22 | def count(query) do
23 | aggregate(query, :count, :id)
24 | end
25 |
26 | def pages(query, page_size) do
27 | Stream.iterate(:ok, & &1)
28 | |> Stream.scan({nil, nil}, fn _, {last_id, _} ->
29 | items = page(query, last_id, page_size)
30 | last = List.last(items)
31 | {last && last.id, items}
32 | end)
33 | |> Stream.map(&elem(&1, 1))
34 | |> Stream.take_while(&(length(&1) > 0))
35 | end
36 |
37 | defp page(query, last_id, page_size) do
38 | import Ecto.Query
39 |
40 | query =
41 | from x in query,
42 | order_by: x.id,
43 | limit: ^page_size
44 |
45 | query =
46 | case last_id do
47 | nil ->
48 | query
49 |
50 | id ->
51 | where(query, [x], x.id > ^id)
52 | end
53 |
54 | all(query)
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/lib/asciinema/streaming/parser.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Streaming.Parser do
2 | @callback name() :: binary
3 | @callback init() :: term
4 | @callback parse({message :: term, opts :: keyword}, term) ::
5 | {:ok, [{atom, term}], term} | {:error, term}
6 |
7 | alias Asciinema.Streaming.Parser
8 |
9 | def get("raw"), do: %{impl: Parser.Raw, state: Parser.Raw.init()}
10 | def get("v0.alis"), do: %{impl: Parser.AlisV0, state: Parser.AlisV0.init()}
11 | def get("v1.alis"), do: %{impl: Parser.AlisV1, state: Parser.AlisV1.init()}
12 | def get("v2.asciicast"), do: %{impl: Parser.Json, state: Parser.Json.init()}
13 | end
14 |
--------------------------------------------------------------------------------
/lib/asciinema/streaming/parser/raw.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Streaming.Parser.Raw do
2 | @behaviour Asciinema.Streaming.Parser
3 |
4 | @default_size {80, 24}
5 |
6 | def name, do: "raw"
7 |
8 | def init, do: %{first: true, start_time: nil, last_event_id: 0}
9 |
10 | def parse({:binary, text}, %{first: true} = state) do
11 | size = size_from_resize_seq(text) || size_from_script_start_message(text) || @default_size
12 |
13 | commands = [
14 | init: %{last_id: state.last_event_id, time: 0, term_size: size, term_init: text}
15 | ]
16 |
17 | {:ok, commands, %{state | first: false, start_time: Timex.now()}}
18 | end
19 |
20 | def parse({:binary, text}, state) do
21 | {id, state} = get_next_id(state)
22 | time = stream_time(state)
23 |
24 | {:ok, [output: %{id: id, time: time, text: text}], state}
25 | end
26 |
27 | defp size_from_resize_seq(text) do
28 | with [_, rows, cols] <- Regex.run(~r/\x1b\[8;(\d+);(\d+)t/, text) do
29 | {String.to_integer(cols), String.to_integer(rows)}
30 | end
31 | end
32 |
33 | defp size_from_script_start_message(text) do
34 | with [_, cols, rows] <- Regex.run(~r/\[.*COLUMNS="(\d{1,3})" LINES="(\d{1,3})".*\]/, text) do
35 | {String.to_integer(cols), String.to_integer(rows)}
36 | end
37 | end
38 |
39 | defp get_next_id(state) do
40 | id = state.last_event_id + 1
41 |
42 | {id, %{state | last_event_id: id}}
43 | end
44 |
45 | defp stream_time(state), do: Timex.diff(Timex.now(), state.start_time, :microsecond)
46 | end
47 |
--------------------------------------------------------------------------------
/lib/asciinema/streaming/stream.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Streaming.Stream do
2 | use Ecto.Schema
3 |
4 | schema "streams" do
5 | field :public_token, :string
6 | field :producer_token, :string
7 | field :visibility, Ecto.Enum, values: ~w[private unlisted public]a, default: :unlisted
8 | field :term_cols, :integer
9 | field :term_rows, :integer
10 | field :term_type, :string
11 | field :term_version, :string
12 | field :term_theme_name, :string
13 | field :term_theme_fg, :string
14 | field :term_theme_bg, :string
15 | field :term_theme_palette, :string
16 | field :term_theme_prefer_original, :boolean, default: true
17 | field :term_line_height, :float
18 | field :term_font_family, :string
19 | field :online, :boolean
20 | field :last_activity_at, :naive_datetime
21 | field :last_started_at, :naive_datetime
22 | field :title, :string
23 | field :description, :string
24 | field :shell, :string
25 | field :user_agent, :string
26 | field :current_viewer_count, :integer
27 | field :peak_viewer_count, :integer
28 | field :buffer_time, :float
29 | field :protocol, :string
30 | field :snapshot, Asciinema.Ecto.Type.Snapshot
31 |
32 | timestamps()
33 |
34 | belongs_to :user, Asciinema.Accounts.User
35 | end
36 |
37 | defimpl Phoenix.Param do
38 | def to_param(stream), do: stream.public_token
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/asciinema/streaming/stream_supervisor.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Streaming.StreamSupervisor do
2 | use DynamicSupervisor
3 | alias Asciinema.Streaming.StreamServer
4 | require Logger
5 |
6 | def start_link(init_arg) do
7 | DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
8 | end
9 |
10 | @impl true
11 | def init(_init_arg) do
12 | DynamicSupervisor.init(strategy: :one_for_one)
13 | end
14 |
15 | def start_child(id) do
16 | Logger.debug("stream sup: starting server for stream #{id}")
17 | DynamicSupervisor.start_child(__MODULE__, {StreamServer, id})
18 | end
19 |
20 | def ensure_child(id) do
21 | case start_child(id) do
22 | {:error, {:already_started, pid}} ->
23 | Logger.debug("stream sup: server already exists for stream #{id}")
24 | {:ok, pid}
25 |
26 | otherwise ->
27 | otherwise
28 | end
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/lib/asciinema/string_utils.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.StringUtils do
2 | def valid_part(invalid_str, str) do
3 | case String.chunk(invalid_str <> str, :valid) do
4 | [] ->
5 | {"", ""}
6 |
7 | chunks ->
8 | str =
9 | chunks
10 | |> Enum.take(Enum.count(chunks) - 1)
11 | |> Enum.filter(&String.valid?/1)
12 | |> Enum.join()
13 |
14 | last = Enum.at(chunks, -1)
15 |
16 | if String.valid?(last) do
17 | {str <> last, ""}
18 | else
19 | {str, last}
20 | end
21 | end
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/lib/asciinema/url_provider.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.UrlProvider do
2 | @type token :: String.t()
3 | @type url :: String.t()
4 |
5 | @callback sign_up(token) :: url
6 | @callback login(token) :: url
7 | @callback account_deletion(token) :: url
8 | end
9 |
--------------------------------------------------------------------------------
/lib/asciinema/vt.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Vt do
2 | use Rustler, otp_app: :asciinema, crate: :vt_nif
3 |
4 | def with_vt(cols, rows, opts \\ [], f) do
5 | scrollback_limit = Keyword.get(opts, :scrollback_limit, 100)
6 |
7 | with {:ok, vt} <- new(cols, rows, scrollback_limit), do: f.(vt)
8 | end
9 |
10 | # When NIF is loaded, it will override following functions.
11 |
12 | @spec new(integer, integer, integer | nil) :: {:ok, reference} | {:error, :invalid_size}
13 | def new(_cols, _rows, _scrollback_limit), do: :erlang.nif_error(:nif_not_loaded)
14 |
15 | @spec feed(reference, binary) :: :ok
16 | def feed(_vt, _str), do: :erlang.nif_error(:nif_not_loaded)
17 |
18 | @spec resize(reference, integer, integer) :: :ok
19 | def resize(_vt, _cols, _rows), do: :erlang.nif_error(:nif_not_loaded)
20 |
21 | @spec dump(reference) :: binary
22 | def dump(_vt), do: :erlang.nif_error(:nif_not_loaded)
23 |
24 | @spec dump_screen(reference) :: {:ok, {list(list({binary, map})), {integer, integer} | nil}}
25 | def dump_screen(_vt), do: :erlang.nif_error(:nif_not_loaded)
26 |
27 | @spec text(reference) :: binary
28 | def text(_vt), do: :erlang.nif_error(:nif_not_loaded)
29 | end
30 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/delete_unclaimed_recordings.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.DeleteUnclaimedRecordings do
2 | use Oban.Worker,
3 | unique: [
4 | period: :infinity,
5 | states: [:scheduled, :available, :executing, :retryable]
6 | ]
7 |
8 | require Logger
9 |
10 | @impl Oban.Worker
11 | def perform(_job) do
12 | hide_unclaimed_recordings(Asciinema.unclaimed_recording_ttl(:hide))
13 | delete_unclaimed_recordings(Asciinema.unclaimed_recording_ttl(:delete))
14 |
15 | :ok
16 | end
17 |
18 | defp hide_unclaimed_recordings(nil), do: :ok
19 |
20 | defp hide_unclaimed_recordings(days) do
21 | count = Asciinema.hide_unclaimed_recordings(days)
22 |
23 | if count > 0 do
24 | Logger.info("hid #{count} unclaimed recordings")
25 | end
26 | end
27 |
28 | defp delete_unclaimed_recordings(nil), do: :ok
29 |
30 | defp delete_unclaimed_recordings(days) do
31 | count = Asciinema.delete_unclaimed_recordings(days)
32 |
33 | if count > 0 do
34 | Logger.info("deleted #{count} unclaimed recordings")
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/generate_snapshots.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.GenerateSnapshots do
2 | use Oban.Worker,
3 | unique: [
4 | period: :infinity,
5 | states: [:available, :retryable]
6 | ]
7 |
8 | alias Asciinema.Recordings
9 | alias Asciinema.Workers.UpdateSnapshot
10 |
11 | @impl Oban.Worker
12 | def perform(_job) do
13 | asciicasts =
14 | :snapshotless
15 | |> Recordings.query()
16 | |> Recordings.stream()
17 |
18 | for asciicast <- asciicasts do
19 | Oban.insert!(UpdateSnapshot.new(%{asciicast_id: asciicast.id}))
20 | end
21 |
22 | :ok
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/initial_seed.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.InitialSeed do
2 | use Oban.Worker
3 | require Logger
4 |
5 | @impl Oban.Worker
6 | def perform(_job) do
7 | user = Asciinema.Accounts.ensure_asciinema_user()
8 | :ok = Asciinema.Recordings.ensure_welcome_asciicast(user)
9 |
10 | Logger.info("database seeded successfully")
11 |
12 | :ok
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/mark_offline_streams.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.MarkOfflineStreams do
2 | use Oban.Worker,
3 | unique: [
4 | period: :infinity,
5 | states: [:scheduled, :available, :executing, :retryable]
6 | ]
7 |
8 | alias Asciinema.Streaming
9 | require Logger
10 |
11 | @impl Oban.Worker
12 | def perform(_job) do
13 | count = Streaming.mark_inactive_streams_offline()
14 |
15 | if count > 0 do
16 | Logger.info("marked #{count} streams offline")
17 | end
18 |
19 | :ok
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/migrate_recording_files.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.MigrateRecordingFiles do
2 | use Oban.Worker,
3 | unique: [
4 | period: :infinity,
5 | states: [:available, :retryable]
6 | ]
7 |
8 | require Logger
9 | alias Asciinema.Recordings
10 |
11 | @impl Oban.Worker
12 | def perform(%Oban.Job{args: %{"asciicast_id" => id}}) do
13 | Logger.info("migrating file for recording #{id}...")
14 | Recordings.migrate_file(id)
15 | Logger.info("recording #{id} file migrated")
16 |
17 | :ok
18 | end
19 |
20 | def perform(%Oban.Job{args: %{"user_id" => user_id}}) do
21 | asciicasts =
22 | {:user_id, user_id}
23 | |> Recordings.query()
24 | |> Recordings.stream()
25 | |> Recordings.migratable()
26 |
27 | for asciicast <- asciicasts do
28 | Oban.insert!(__MODULE__.new(%{asciicast_id: asciicast.id}))
29 | end
30 |
31 | :ok
32 | end
33 |
34 | def perform(_job) do
35 | asciicasts =
36 | Recordings.query()
37 | |> Recordings.stream()
38 | |> Recordings.migratable()
39 |
40 | for asciicast <- asciicasts do
41 | Oban.insert!(__MODULE__.new(%{asciicast_id: asciicast.id}))
42 | end
43 |
44 | :ok
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/asciinema/workers/update_snapshot.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Workers.UpdateSnapshot do
2 | use Oban.Worker,
3 | unique: [
4 | period: :infinity,
5 | states: [:available, :retryable]
6 | ]
7 |
8 | alias Asciinema.Recordings
9 | require Logger
10 |
11 | @impl Oban.Worker
12 | def perform(%Oban.Job{args: %{"asciicast_id" => id}}) do
13 | Logger.info("updating snapshot for recording #{id}...")
14 |
15 | with {:ok, asciicast} <- Recordings.fetch_asciicast(id),
16 | {:ok, _} <- Recordings.update_snapshot(asciicast) do
17 | Logger.info("snapshot for recording #{id} updated")
18 |
19 | :ok
20 | else
21 | {:error, :not_found} -> :discard
22 | {:error, _} = result -> result
23 | result -> {:error, result}
24 | end
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/components/layouts.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.Layouts do
2 | @moduledoc """
3 | This module holds different layouts used by your application.
4 |
5 | See the `layouts` directory for all templates available.
6 | The "root" layout is a skeleton rendered as part of the
7 | application router. The "app" layout is set as the default
8 | layout on both `use AsciinemaAdmin, :controller` and
9 | `use AsciinemaAdmin, :live_view`.
10 | """
11 | use AsciinemaAdmin, :html
12 |
13 | embed_templates "layouts/*"
14 | end
15 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/components/layouts/app.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Admin panel - asciinema
9 |
47 |
48 |
49 |
50 |
55 |
56 |
57 | {@inner_content}
58 |
59 |
60 |
61 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/cli_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.CliController do
2 | use AsciinemaAdmin, :controller
3 | alias Asciinema.Accounts
4 |
5 | def create(conn, %{"user_id" => user_id, "cli" => %{"token" => token}}) do
6 | user = Accounts.get_user(user_id)
7 | install_id = extract_install_id(token)
8 |
9 | case Asciinema.register_cli(user, install_id) do
10 | :ok ->
11 | redirect(conn, to: ~p"/admin/users/#{user}")
12 |
13 | {:error, reason} ->
14 | redirect(conn, to: ~p"/admin/users/#{user}?error=#{reason}")
15 | end
16 | end
17 |
18 | defp extract_install_id(value) do
19 | value
20 | |> URI.parse()
21 | |> Map.get(:path)
22 | |> String.split("/")
23 | |> List.last()
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/home_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.HomeController do
2 | use AsciinemaAdmin, :controller
3 |
4 | def show(conn, _params) do
5 | redirect(conn, to: ~p"/admin/users")
6 | end
7 | end
8 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/home_html.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.HomeHTML do
2 | use AsciinemaAdmin, :html
3 |
4 | embed_templates "home_html/*"
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/user_html.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.UserHTML do
2 | use AsciinemaAdmin, :html
3 |
4 | embed_templates "user_html/*"
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/user_html/edit.html.heex:
--------------------------------------------------------------------------------
1 | Users › {@user.username || @user.id}
2 |
3 |
4 |
5 |
6 | <.form :let={f} for={@changeset} action={~p"/admin/users/#{@user}"} method="PUT">
7 |
8 | <.label for={f[:username]}>Username
9 | <.input field={f[:username]} required />
10 | <.error field={f[:username]} />
11 |
12 |
13 |
14 | <.label for={f[:email]}>Email
15 | <.input field={f[:email]} type="email" required />
16 | <.error field={f[:email]} />
17 |
18 |
19 |
20 | <.label for={f[:name]}>Display name
21 | <.input field={f[:name]} />
22 | <.error field={f[:name]} />
23 |
24 |
25 |
26 |
27 | Streaming
28 |
29 |
30 | <.input field={f[:streaming_enabled]} type="checkbox" />
31 | <.label for={f[:streaming_enabled]}>Enabled
32 |
33 |
34 |
35 | <.label for={f[:stream_limit]}>Stream limit
36 | <.input field={f[:stream_limit]} type="number" min="0" placeholder="no limit" />
37 | <.error field={f[:stream_limit]} />
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/controllers/user_html/new.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | <.form :let={f} for={@changeset} action={~p"/admin/users"}>
7 |
8 | <.label for={f[:email]}>Email
9 | <.input field={f[:email]} type="email" required />
10 | <.error field={f[:email]} />
11 |
12 |
13 |
14 | <.label for={f[:username]}>Username
15 | <.input field={f[:username]} required />
16 | <.error field={f[:username]} />
17 |
18 |
19 |
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :asciinema
3 |
4 | @session_options [
5 | store: :cookie,
6 | key: "_asciinema_admin_key",
7 | signing_salt: "qJL+3s0T",
8 | same_site: "Lax"
9 | ]
10 |
11 | socket "/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]]
12 |
13 | # Serve at "/" the static files from "priv/static" directory.
14 | #
15 | # You should set gzip to true if you are running phx.digest
16 | # when deploying your static files in production.
17 | plug Plug.Static,
18 | at: "/",
19 | from: :asciinema,
20 | gzip: true,
21 | only: AsciinemaAdmin.static_paths()
22 |
23 | if code_reloading? do
24 | socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
25 | plug Phoenix.LiveReloader
26 | plug Phoenix.CodeReloader
27 | plug Phoenix.Ecto.CheckRepoStatus, otp_app: :asciinema
28 | end
29 |
30 | plug Phoenix.LiveDashboard.RequestLogger,
31 | param_key: "request_logger",
32 | cookie_key: "request_logger"
33 |
34 | plug Plug.Parsers,
35 | parsers: [:urlencoded, :multipart, :json],
36 | pass: ["*/*"],
37 | json_decoder: Phoenix.json_library()
38 |
39 | plug Plug.MethodOverride
40 | plug Plug.Head
41 | plug Plug.Session, @session_options
42 | plug AsciinemaAdmin.Router
43 | end
44 |
--------------------------------------------------------------------------------
/lib/asciinema_admin/router.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaAdmin.Router do
2 | use AsciinemaAdmin, :router
3 | import Oban.Web.Router
4 | import Phoenix.LiveDashboard.Router
5 |
6 | pipeline :browser do
7 | plug :accepts, ["html"]
8 | plug :fetch_session
9 | plug :fetch_flash
10 | plug :fetch_live_flash
11 | plug :protect_from_forgery
12 | plug :put_secure_browser_headers
13 | end
14 |
15 | scope "/", AsciinemaAdmin do
16 | pipe_through :browser
17 |
18 | get "/", HomeController, :show
19 | end
20 |
21 | scope "/admin", AsciinemaAdmin do
22 | pipe_through :browser
23 |
24 | get "/", HomeController, :show
25 | get "/users/lookup", UserController, :lookup
26 |
27 | resources "/users", UserController do
28 | resources "/clis", CliController
29 | end
30 |
31 | live_dashboard "/dashboard", metrics: Asciinema.Telemetry
32 | oban_dashboard("/oban")
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/lib/asciinema_web/caching.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.Caching do
2 | import Plug.Conn
3 |
4 | def put_etag(conn, content) do
5 | etag = Crypto.md5(to_string(content))
6 |
7 | conn
8 | |> put_resp_header("etag", etag)
9 | |> register_before_send(fn conn ->
10 | if etag in get_req_header(conn, "if-none-match") do
11 | resp(conn, 304, "")
12 | else
13 | conn
14 | end
15 | end)
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/lib/asciinema_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.UserSocket do
2 | use Phoenix.Socket
3 |
4 | ## Channels
5 | # channel "room:*", AsciinemaWeb.RoomChannel
6 |
7 | # Socket params are passed from the client and can
8 | # be used to verify and authenticate a user. After
9 | # verification, you can put default assigns into
10 | # the socket that will be set for all channels, ie
11 | #
12 | # {:ok, assign(socket, :user_id, verified_user_id)}
13 | #
14 | # To deny connection, return `:error`.
15 | #
16 | # See `Phoenix.Token` documentation for examples in
17 | # performing token verification on connect.
18 | def connect(_params, socket, _connect_info) do
19 | {:ok, socket}
20 | end
21 |
22 | # Socket id's are topics that allow you to identify all sockets for a given user:
23 | #
24 | # def id(socket), do: "user_socket:#{socket.assigns.user_id}"
25 | #
26 | # Would allow you to broadcast a "disconnect" event and terminate
27 | # all active sockets and channels for a given user:
28 | #
29 | # AsciinemaWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
30 | #
31 | # Returning `nil` makes this socket anonymous.
32 | def id(_socket), do: nil
33 | end
34 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.Icons do
2 | use Phoenix.Component
3 |
4 | embed_templates "icons/*"
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/adjustments_horizontal_mini_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/cog_8_tooth_mini_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/download_mini_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/envelope_outline_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
16 |
17 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/eye_solid_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
10 |
11 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/info_outline_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
16 |
17 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/info_solid_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/live_icon.html.heex:
--------------------------------------------------------------------------------
1 | LIVE
2 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/offline_icon.html.heex:
--------------------------------------------------------------------------------
1 | OFFLINE
2 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/share_mini_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/terminal_solid_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/user_circle_outline_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
16 |
17 |
--------------------------------------------------------------------------------
/lib/asciinema_web/components/icons/user_solid_icon.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/avatar_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.AvatarController do
2 | use AsciinemaWeb, :controller
3 | alias Asciinema.Accounts
4 |
5 | @one_day 24 * 60 * 60
6 |
7 | def show(conn, %{"id" => id}) do
8 | with {:ok, user} <- Accounts.fetch_user(id) do
9 | conn
10 | |> put_resp_header("cache-control", "public, max-age=#{@one_day}")
11 | |> render("show.svg", user: user)
12 | end
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/avatar_svg.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.AvatarSVG do
2 | def show(%{user: user}) do
3 | email = user.email || "#{user.id}@asciinema"
4 |
5 | {:safe, IdenticonSvg.generate(email, 7, :split2, 1.0, 1)}
6 | end
7 | end
8 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/cli_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.CliController do
2 | use AsciinemaWeb, :controller
3 |
4 | plug :require_current_user
5 |
6 | def register(conn, %{"install_id" => install_id}) do
7 | case Asciinema.register_cli(conn.assigns.current_user, install_id) do
8 | :ok ->
9 | conn
10 | |> put_flash(:info, "CLI successfully authenticated with your account")
11 | |> redirect_to_profile()
12 |
13 | {:error, :token_taken} ->
14 | conn
15 | |> put_flash(:error, "This CLI has been authenticated with a different user account")
16 | |> redirect_to_profile()
17 |
18 | {:error, :token_invalid} ->
19 | conn
20 | |> put_flash(:error, "Invalid installation ID - make sure to paste the URL correctly")
21 | |> redirect(to: ~p"/")
22 |
23 | {:error, :cli_revoked} ->
24 | conn
25 | |> put_flash(:error, "This CLI authentication has been revoked")
26 | |> redirect(to: ~p"/")
27 | end
28 | end
29 |
30 | def delete(conn, %{"id" => id}) do
31 | case Asciinema.revoke_cli(conn.assigns.current_user, id) do
32 | :ok ->
33 | conn
34 | |> put_flash(:info, "CLI authentication revoked")
35 | |> redirect(to: ~p"/user/edit")
36 |
37 | {:error, :not_found} ->
38 | conn
39 | |> put_flash(:error, "CLI not found")
40 | |> redirect(to: ~p"/user/edit")
41 | end
42 | end
43 |
44 | defp redirect_to_profile(conn) do
45 | user = conn.assigns.current_user
46 |
47 | if user.username do
48 | redirect(conn, to: profile_path(user))
49 | else
50 | redirect(conn, to: ~p"/username/new")
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/error_html.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.ErrorHTML do
2 | use AsciinemaWeb, :html
3 |
4 | embed_templates "error_html/*"
5 |
6 | def render(template, _assigns) do
7 | Phoenix.Controller.status_message_from_template(template)
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/error_html/403.html.eex:
--------------------------------------------------------------------------------
1 | 403 Forbidden
2 | You're not authorized to access this page. Sorry!
3 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/error_html/404.html.eex:
--------------------------------------------------------------------------------
1 | 404 Not Found
2 | This page doesn't exist. Sorry!
3 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/error_json.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.ErrorJSON do
2 | def render(template, _assigns) do
3 | %{error: Phoenix.Controller.status_message_from_template(template)}
4 | end
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/error_text.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.ErrorTEXT do
2 | def render(template, _assigns) do
3 | Phoenix.Controller.status_message_from_template(template)
4 | end
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/fallback_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.FallbackController do
2 | use AsciinemaWeb, :controller
3 |
4 | def call(conn, {:error, :bad_request}), do: error(conn, 400)
5 | def call(conn, {:error, :forbidden}), do: error(conn, 403)
6 | def call(conn, {:error, :not_found}), do: error(conn, 404)
7 |
8 | defp error(conn, status) do
9 | conn
10 | |> put_layout(:simple)
11 | |> put_status(status)
12 | |> put_view(
13 | html: AsciinemaWeb.ErrorHTML,
14 | json: AsciinemaWeb.ErrorJSON,
15 | cast: AsciinemaWeb.ErrorJSON,
16 | js: AsciinemaWeb.ErrorTEXT,
17 | txt: AsciinemaWeb.ErrorTEXT,
18 | svg: AsciinemaWeb.ErrorTEXT,
19 | png: AsciinemaWeb.ErrorTEXT,
20 | gif: AsciinemaWeb.ErrorTEXT,
21 | xml: AsciinemaWeb.ErrorTEXT
22 | )
23 | |> render(:"#{status}")
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/login_html.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.LoginHTML do
2 | use AsciinemaWeb, :html
3 |
4 | embed_templates "login_html/*"
5 | end
6 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/login_html/sent.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | <.envelope_outline_icon /> Check your inbox
6 |
7 |
8 |
9 |
10 |
11 | We've sent an email with one-time login link to your email address.
12 | Click on the link to log in to your account.
13 |
14 |
15 |
16 | If the email doesn't show up in your inbox, check your spam folder,
17 | or try again in a moment.
18 |
19 |
20 |
21 |
2 | <.link href={~p"/a/#{@asciicast}"} class="thumbnail-link">
3 |
10 |
11 | <.thumbnail asciicast={@asciicast} />
12 |
13 |
14 |
15 |
16 | <.link href={~p"/a/#{@asciicast}"}>{title(@asciicast)}
17 | {duration(@asciicast)}
18 |
19 |
20 |
21 | <.link href={author_profile_path(@asciicast)} title={author_username(@asciicast)}>
22 | })
23 |
24 |
25 |
26 |
27 | by <.link href={author_profile_path(@asciicast)}>{author_username(@asciicast)}
28 | <%= if !assigns[:no_created_at] do %>
29 | {time_ago_tag(@asciicast.inserted_at)}
30 | <% end %>
31 | <.visibility_badge
32 | :if={assigns[:conn] && owned_by_current_user?(@asciicast, @conn)}
33 | visibility={@asciicast.visibility}
34 | />
35 | <.featured_badge :if={@asciicast.featured} />
36 |
37 |
38 |
2 |
3 |
4 |
This recording has been deleted
5 |
6 | <%= if @ttl do %>
7 |
8 | All unclaimed recordings are automatically deleted {@ttl} days after upload.
9 |
10 |
11 |
12 | See here
13 | for more details.
14 |
15 | <% end %>
16 |
17 |
18 |
Looking for GIF?
2 |
3 | You can use agg to do it
4 | yourself. Once you have it installed run the following commands in your
5 | terminal:
6 |
7 | wget -O <%= @asciicast_id %>.cast <%= @file_url %>
8 | agg <%= @asciicast_id %>.cast <%= @asciicast_id %>.gif
9 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/recording_html/head_for_show.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 |
10 |
11 |
12 | ".png"} />
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 | ".png"} />
22 |
23 |
28 |
29 | <%= if @asciicast.visibility != :public do %>
30 |
31 |
32 | <% end %>
33 |
34 | <.theme_style theme={theme(@asciicast)} />
35 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/recording_html/iframe.html.heex:
--------------------------------------------------------------------------------
1 | <.theme_style theme={theme(@asciicast)} />
2 |
3 |
4 |
5 |
6 | Recorded with asciinema
7 |
8 |
9 |
40 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/recording_html/secret_badge.html.heex:
--------------------------------------------------------------------------------
1 |
5 | secret
6 |
7 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/recording_html/theme_style.html.heex:
--------------------------------------------------------------------------------
1 |
11 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/recording_html/thumbnail.html.heex:
--------------------------------------------------------------------------------
1 |
5 |
![]({~p"/a/#{@asciicast}")
".svg?f=t&v=#{svg_cache_key(@asciicast)}"} />
6 |
2 |
3 |
4 |
Verifying link...
5 |
6 |
7 |
2 | <.link href={~p"/s/#{@stream}"} class="thumbnail-link">
3 |
10 |
11 | <.thumbnail stream={@stream} />
12 |
13 |
14 |
15 |
16 | <.link href={~p"/s/#{@stream}"}>{title(@stream)}
17 | <.live_icon :if={@stream.online} />
18 |
19 |
20 |
21 | <.link href={author_profile_path(@stream)} title={author_username(@stream)}>
22 | })
23 |
24 |
25 |
26 |
27 | by <.link href={author_profile_path(@stream)}>{author_username(@stream)}
28 | <.visibility_badge
29 | :if={assigns[:conn] && owned_by_current_user?(@stream, @conn)}
30 | visibility={@stream.visibility}
31 | />
32 |
33 |
34 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/stream_html/visibility_badge.html.heex:
--------------------------------------------------------------------------------
1 |
6 | public
7 |
8 |
13 | unlisted
14 |
15 |
16 | private
17 |
18 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/user_html.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.UserHTML do
2 | use AsciinemaWeb, :html
3 | import AsciinemaWeb.ErrorHelpers
4 | import Scrivener.HTML
5 | alias Asciinema.Fonts
6 | alias AsciinemaWeb.{DefaultAvatar, MediaView, RecordingHTML}
7 |
8 | embed_templates "user_html/*"
9 |
10 | defdelegate theme_options, to: MediaView
11 | defdelegate font_family_options, to: MediaView
12 | defdelegate default_font_display_name, to: Fonts
13 |
14 | def avatar_url(user) do
15 | DefaultAvatar.url(user)
16 | end
17 |
18 | def username(user) do
19 | user.username || user.temporary_username || "user:#{user.id}"
20 | end
21 |
22 | def display_name(user) do
23 | if String.trim("#{user.name}") != "" do
24 | user.name
25 | end
26 | end
27 |
28 | def joined_at(user) do
29 | Timex.format!(user.inserted_at, "{Mfull} {D}, {YYYY}")
30 | end
31 |
32 | def active_clis(clis) do
33 | clis
34 | |> Enum.reject(& &1.revoked_at)
35 | |> Enum.sort_by(&(-Timex.to_unix(&1.inserted_at)))
36 | end
37 |
38 | def revoked_clis(clis) do
39 | clis
40 | |> Enum.filter(& &1.revoked_at)
41 | |> Enum.sort_by(&(-Timex.to_unix(&1.inserted_at)))
42 | end
43 | end
44 |
--------------------------------------------------------------------------------
/lib/asciinema_web/controllers/user_html/delete.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Are you sure?
5 |
6 |
This will permanently delete your account and all associated recordings.
7 |
8 | <.form for={@conn} method="delete" action={~p"/user"}>
9 | <.input name="confirmed" type="hidden" value="1" />
10 | <.input name="token" type="hidden" value={@token} />
11 | <.button type="submit" class="btn btn-danger" data-confirm="There's no going back!">
12 | Yes, delete my account
13 |
14 |
15 |
16 |
17 |
2 |
3 |
4 |
Verifying link...
5 |
6 |
7 |
2 |
3 |
4 |
Choose your username
5 |
6 |
7 |
8 | Every asciinema user gets a profile page at <%= url(~p"/") %>~username.
9 |
10 |
11 | <.form :let={f} for={@changeset} action={~p"/username"} class="username-form" method="post">
12 |
31 |
32 |
36 |
37 |
38 |
39 |
4 | {message}
5 |
8 |
9 |
10 | <% end %>
11 |
12 | <%= if message = Phoenix.Flash.get(@flash, :error) do %>
13 |
14 |
15 | {message}
16 |
19 |
20 |
21 | <% end %>
22 |
--------------------------------------------------------------------------------
/lib/asciinema_web/templates/layout/_footer.html.heex:
--------------------------------------------------------------------------------
1 |
14 |
--------------------------------------------------------------------------------
/lib/asciinema_web/templates/layout/app.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | {page_title(@conn)}
9 |
10 |
11 |
12 | <%= if function_exported?(view_module(@conn), :head, 2) do %>
13 | {view_module(@conn).head(view_template(@conn), assigns)}
14 | <% end %>
15 |
16 |
17 | body_class(@conn)}>
18 | {render("_header.html", conn: @conn, current_user: @current_user)}
19 | {render("_flash.html", flash: @flash)}
20 |
21 |
22 | {@inner_content}
23 |
24 |
25 | {render("_footer.html", conn: @conn)}
26 |
29 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/lib/asciinema_web/templates/layout/email.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | {@inner_content}
8 |
9 |
10 |
--------------------------------------------------------------------------------
/lib/asciinema_web/templates/layout/iframe.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 | {@inner_content}
12 |
15 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/lib/asciinema_web/templates/layout/simple.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | {page_title(@conn)}
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | {@inner_content}
17 |
18 |
19 |
.+
}s
10 | end
11 | )
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/test/asciinema_web/controllers/recording_svg_test.exs:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.RecordingSvgTest do
2 | use ExUnit.Case, async: true
3 | alias Asciinema.Recordings.Snapshot
4 | alias AsciinemaWeb.RecordingSVG
5 | import Asciinema.Factory
6 |
7 | describe "show/1" do
8 | test "renders SVG document" do
9 | asciicast =
10 | build(:asciicast, snapshot: Snapshot.new([[["foobar", %{}, 1]], [["bazqux", %{}, 1]]]))
11 |
12 | svg = render_svg(asciicast)
13 |
14 | assert svg =~ ~r/^<\?xml.+foobar.+bazqux/s
15 | end
16 |
17 | test "supports RGB color in fg/bg text attrs" do
18 | asciicast =
19 | build(:asciicast,
20 | snapshot:
21 | Snapshot.new([
22 | [["foo", %{"fg" => [16, 32, 48]}, 1], ["bar", %{"bg" => "rgb(64,80,96)"}, 1]],
23 | [["baz", %{"fg" => "#708090"}, 1]]
24 | ])
25 | )
26 |
27 | svg = render_svg(asciicast)
28 |
29 | assert svg =~ "#102030"
30 | assert svg =~ "rgb(64,80,96)"
31 | assert svg =~ "#708090"
32 | end
33 | end
34 |
35 | defp render_svg(asciicast) do
36 | Phoenix.LiveViewTest.rendered_to_string(RecordingSVG.show(%{asciicast: asciicast}))
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/test/asciinema_web/controllers/username_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.UsernameControllerTest do
2 | use AsciinemaWeb.ConnCase
3 | import Asciinema.Factory
4 |
5 | describe "setting username" do
6 | test "requires logged in user", %{conn: conn} do
7 | conn = get(conn, "/username/new")
8 | assert redirected_to(conn, 302) == "/login/new"
9 | end
10 |
11 | test "displays form", %{conn: conn} do
12 | user = insert(:user)
13 | conn = log_in(conn, user)
14 | conn = get(conn, "/username/new")
15 | assert html_response(conn, 200) =~ ~r/your username/i
16 | end
17 |
18 | test "redirects to profile on success", %{conn: conn} do
19 | user = insert(:user)
20 | conn = log_in(conn, user)
21 |
22 | conn = post conn, "/username", %{user: %{username: "ricksanchez"}}
23 |
24 | assert response(conn, 302)
25 | location = List.first(get_resp_header(conn, "location"))
26 | assert location == "/~ricksanchez"
27 | end
28 |
29 | test "redisplays form on error", %{conn: conn} do
30 | user = insert(:user)
31 | conn = log_in(conn, user)
32 |
33 | conn = post conn, "/username", %{user: %{username: "---"}}
34 |
35 | assert html_response(conn, 422) =~ "only letters"
36 | end
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/test/asciinema_web/controllers/webfinger_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.WebFingerControllerTest do
2 | use AsciinemaWeb.ConnCase
3 | import Asciinema.Factory
4 |
5 | setup [:create_user]
6 |
7 | describe "show" do
8 | test "returns basic info", %{conn: conn} do
9 | conn = get(conn, ~p"/.well-known/webfinger?resource=acct:Pinky@localhost")
10 |
11 | assert json_response(conn, 200) == %{
12 | "subject" => "acct:Pinky@localhost",
13 | "aliases" => [
14 | url(~p"/~Pinky")
15 | ],
16 | "links" => [
17 | %{
18 | "rel" => "http://webfinger.net/rel/profile-page",
19 | "type" => "text/html",
20 | "href" => url(~p"/~Pinky")
21 | }
22 | ]
23 | }
24 | end
25 |
26 | test "does case-insensitive acct lookup", %{conn: conn} do
27 | conn = get(conn, ~p"/.well-known/webfinger?resource=acct:pinky@lOcaLhOst")
28 |
29 | assert %{"subject" => "acct:Pinky@localhost"} = json_response(conn, 200)
30 | end
31 |
32 | test "returns 404 when username not found", %{conn: conn} do
33 | conn = get(conn, ~p"/.well-known/webfinger?resource=acct:nope@localhost")
34 |
35 | assert json_response(conn, 404)
36 | end
37 |
38 | test "returns 404 when domain doesn't match", %{conn: conn} do
39 | conn = get(conn, ~p"/.well-known/webfinger?resource=acct:pinky@nope.nope")
40 |
41 | assert json_response(conn, 404)
42 | end
43 | end
44 |
45 | defp create_user(_) do
46 | %{user: insert(:user, username: "Pinky")}
47 | end
48 | end
49 |
--------------------------------------------------------------------------------
/test/asciinema_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.LayoutViewTest do
2 | use AsciinemaWeb.ConnCase, async: true
3 |
4 | # When testing helpers, you may want to import Phoenix.HTML and
5 | # use functions such as safe_to_string() to convert the helper
6 | # result into an HTML string.
7 | # import Phoenix.HTML
8 | end
9 |
--------------------------------------------------------------------------------
/test/fixtures/1/full.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 1,
3 | "width": 96,
4 | "height": 26,
5 | "duration": 11.146430,
6 | "command": "/bin/bash",
7 | "title": "bashing :)",
8 | "env": {
9 | "TERM": "screen-256color",
10 | "SHELL": "/bin/zsh"
11 | },
12 | "stdout": [
13 | [1.234567, "foo bar"],
14 | [5.678987, "baz qux"],
15 | [3.456789, "żółć jaźń"]
16 | ]
17 | }
18 |
--------------------------------------------------------------------------------
/test/fixtures/1/invalid.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 1,
3 | "height": 26,
4 | "duration": 11.146430015564,
5 | "command": "/bin/bash",
6 | "title": "bashing :)",
7 | "env": {
8 | "TERM": "screen-256color",
9 | "SHELL": "/bin/zsh"
10 | },
11 | "stdout": [
12 | [1.234567, "foo bar"],
13 | [5.678987, "baz qux"],
14 | [3.456789, "żółć jaźń"]
15 | ]
16 | }
17 |
--------------------------------------------------------------------------------
/test/fixtures/1/minimal.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 1,
3 | "width": 96,
4 | "height": 26,
5 | "duration": 8.456789,
6 | "stdout": [
7 | [1.234567, "foo bar"],
8 | [4.419754, "baz qux"],
9 | [2.802468, "żółć jaźń"]
10 | ]
11 | }
12 |
--------------------------------------------------------------------------------
/test/fixtures/1/screenshot.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 1,
3 | "width": 96,
4 | "height": 26,
5 | "duration": 11.146430015564,
6 | "command": "/bin/bash",
7 | "title": "bashing :)",
8 | "env": {
9 | "TERM": "screen-256color",
10 | "SHELL": "/bin/zsh"
11 | },
12 | "stdout": [
13 | [1.234567, "foo \u001b[41mbar\u001b[32m"],
14 | [5.678987, "baz qux"],
15 | [3.456789, "żółć jaźń"]
16 | ]
17 | }
18 |
--------------------------------------------------------------------------------
/test/fixtures/2/blank-lines.cast:
--------------------------------------------------------------------------------
1 | {"version": 2, "width": 96, "height": 26}
2 | [1.234567, "o", "foo bar"]
3 | [5.678987, "o", "baz qux"]
4 |
5 | [8.456789, "o", "żółć jaźń"]
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/test/fixtures/2/full.cast:
--------------------------------------------------------------------------------
1 | {"version": 2, "width": 96, "height": 26, "timestamp": 1506410422, "command": "/bin/bash -l", "title": "bashing :)", "idle_time_limit": 2.5, "env": {"TERM": "screen-256color", "SHELL": "/bin/zsh"}, "theme": {"fg": "#aaaaaa", "bg": "#bbbbbb", "palette": "#151515:#ac4142:#7e8e50:#e5b567:#6c99bb:#9f4e85:#7dd6cf:#d0d0d0:#505050:#ac4142:#7e8e50:#e5b567:#6c99bb:#9f4e85:#7dd6cf:#f5f5f5"}}
2 | [1.234567, "o", "foo bar"]
3 | [2.345670, "i", "\r"]
4 | [5.678987, "o", "baz qux"]
5 | [8.456789, "o", "żółć jaźń"]
6 |
--------------------------------------------------------------------------------
/test/fixtures/2/invalid-theme.cast:
--------------------------------------------------------------------------------
1 | {"version": 2, "width": 96, "height": 26, "theme": {"fg": "white", "bg": "000000", "palette": ""}}
2 | [1.234567, "o", "foo bar"]
3 | [5.678987, "o", "baz qux"]
4 | [8.456789, "o", "żółć jaźń"]
5 |
--------------------------------------------------------------------------------
/test/fixtures/2/minimal.cast:
--------------------------------------------------------------------------------
1 | {"version": 2, "width": 96, "height": 26}
2 | [1.234567, "o", "foo bar"]
3 | [5.678987, "o", "baz qux"]
4 | [8.456789, "o", "żółć jaźń"]
--------------------------------------------------------------------------------
/test/fixtures/3/blank-lines-and-comments.cast:
--------------------------------------------------------------------------------
1 | {"version": 3, "term": {"cols": 96, "rows": 26}}
2 | # stuff
3 | [1.234567, "o", "foo bar"]
4 | [4.44442, "o", "baz qux"]
5 |
6 | # more stuff
7 | [2.802468, "o", "żółć jaźń"]
8 |
9 |
10 | # more and more
11 |
12 |
13 | # stuff
14 |
15 | [1.0, "o", "bye!"]
16 |
17 |
18 |
--------------------------------------------------------------------------------
/test/fixtures/3/full.cast:
--------------------------------------------------------------------------------
1 | {"version": 3, "term": {"cols": 96, "rows": 26, "type": "xterm-ghostty", "version": "ghostty 1.1.3-889478f-nix", "theme": {"fg": "#aaaaaa", "bg": "#bbbbbb", "palette": "#151515:#ac4142:#7e8e50:#e5b567:#6c99bb:#9f4e85:#7dd6cf:#d0d0d0:#505050:#ac4142:#7e8e50:#e5b567:#6c99bb:#9f4e85:#7dd6cf:#f5f5f5"}}, "timestamp": 1744302022, "command": "/bin/bash -l", "title": "bashing :)", "idle_time_limit": 2.5, "env": {"TERM": "xterm-ghostty", "SHELL": "/usr/bin/fish"}}
2 | [1.234567, "o", "foo bar"]
3 | [1.0, "i", "\r"]
4 | [4.678987, "o", "baz qux"]
5 | [1.0, "r", "80x24"]
6 | [2.456789, "o", "żółć jaźń"]
7 |
--------------------------------------------------------------------------------
/test/fixtures/3/minimal.cast:
--------------------------------------------------------------------------------
1 | {"version": 3, "term": {"cols": 96, "rows": 26}}
2 | [1.234567, "o", "foo bar"]
3 | [4.419754, "o", "baz qux"]
4 | [2.802468, "o", "żółć jaźń"]
5 |
--------------------------------------------------------------------------------
/test/fixtures/5/asciicast.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 5,
3 | "width": 96,
4 | "height": 26,
5 | "duration": 11.146430015564,
6 | "command": "/bin/bash",
7 | "title": "bashing :)",
8 | "env": {
9 | "TERM": "screen-256color",
10 | "SHELL": "/bin/zsh"
11 | },
12 | "stdout": [
13 | [1.234567, "foo bar"],
14 | [5.678987, "baz qux"],
15 | [3.456789, "żółć jaźń"]
16 | ]
17 | }
18 |
--------------------------------------------------------------------------------
/test/fixtures/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asciinema/asciinema-server/33dadd53aac1351c27b0f46ee1589ab719896df6/test/fixtures/favicon.png
--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.ChannelCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | channel tests.
5 |
6 | Such tests rely on `Phoenix.ChannelTest` and also
7 | import other functionality to make it easier
8 | to build and query models.
9 |
10 | Finally, if the test case interacts with the database,
11 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | using do
19 | quote do
20 | # Import conveniences for testing with channels
21 | use Phoenix.ChannelTest
22 |
23 | # The default endpoint for testing
24 | @endpoint AsciinemaWeb.Endpoint
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Asciinema.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(Asciinema.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
1 | defmodule AsciinemaWeb.ConnCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | tests that require setting up a connection.
5 |
6 | Such tests rely on `Phoenix.ConnTest` and also
7 | import other functionality to make it easier
8 | to build and query models.
9 |
10 | Finally, if the test case interacts with the database,
11 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | using do
19 | quote do
20 | # The default endpoint for testing
21 | @endpoint AsciinemaWeb.Endpoint
22 |
23 | use AsciinemaWeb, :verified_routes
24 | use Asciinema.OnExit
25 |
26 | # Import conveniences for testing with connections
27 | import Plug.Conn
28 | import Phoenix.ConnTest
29 |
30 | import Asciinema.Fixtures
31 |
32 | alias AsciinemaWeb.Router.Helpers, as: Routes
33 |
34 | defp flash(conn, key) do
35 | Phoenix.Flash.get(conn.assigns.flash, key)
36 | end
37 |
38 | def log_in(conn, user) do
39 | assign(conn, :current_user, user)
40 | end
41 | end
42 | end
43 |
44 | setup tags do
45 | Asciinema.DataCase.setup_sandbox(tags)
46 |
47 | {:ok, conn: Phoenix.ConnTest.build_conn()}
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/test/support/fixtures.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.Fixtures do
2 | def fixture(what, attrs \\ %{})
3 |
4 | def fixture(:upload, attrs) do
5 | fixture(:upload_v1, attrs)
6 | end
7 |
8 | def fixture(:upload_v1, attrs) do
9 | path = Map.get(attrs, :path) || "1/full.json"
10 | filename = Path.basename(path)
11 |
12 | %Plug.Upload{
13 | path: "test/fixtures/#{path}",
14 | filename: filename,
15 | content_type: "application/json"
16 | }
17 | end
18 |
19 | def fixture(:upload_v2, attrs) do
20 | path = Map.get(attrs, :path) || "2/full.cast"
21 | filename = Path.basename(path)
22 |
23 | %Plug.Upload{
24 | path: "test/fixtures/#{path}",
25 | filename: filename,
26 | content_type: "application/octet-stream"
27 | }
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/test/support/on_exit.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.OnExit do
2 | defmacro __using__(_) do
3 | quote do
4 | def on_exit_restore_config(module) do
5 | config = Application.get_env(:asciinema, module, [])
6 | on_exit(fn -> Application.put_env(:asciinema, module, config) end)
7 | end
8 | end
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/test/support/url_provider.ex:
--------------------------------------------------------------------------------
1 | defmodule Asciinema.TestUrlProvider do
2 | @behaviour Asciinema.UrlProvider
3 |
4 | @impl true
5 | def sign_up(token) do
6 | "http://example.com/sign_up/#{token}"
7 | end
8 |
9 | @impl true
10 | def login(token) do
11 | "http://example.com/login/#{token}"
12 | end
13 |
14 | @impl true
15 | def account_deletion(token) do
16 | "http://example.com/account_deletion/#{token}"
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | {:ok, _} = Application.ensure_all_started(:ex_machina)
2 |
3 | ExUnit.configure(exclude: [rsvg: true, vt: true])
4 | ExUnit.start()
5 |
6 | Ecto.Adapters.SQL.Sandbox.mode(Asciinema.Repo, :manual)
7 |
--------------------------------------------------------------------------------
/uploads/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 |
--------------------------------------------------------------------------------