mirror of
https://github.com/plausible/analytics.git
synced 2024-12-19 15:41:56 +03:00
f05dbe1a21
* Fix init_admin * Fix DB url in sample vars
265 lines
7.5 KiB
Elixir
265 lines
7.5 KiB
Elixir
defmodule Plausible.Release do
|
|
use Plausible.Repo
|
|
@app :plausible
|
|
@start_apps [
|
|
:postgrex,
|
|
:ecto
|
|
]
|
|
|
|
def init_admin do
|
|
prepare()
|
|
{admin_email, admin_user, admin_pwd} =
|
|
validate_admin(
|
|
{Application.get_env(:plausible, :admin_email),
|
|
Application.get_env(:plausible, :admin_user),
|
|
Application.get_env(:plausible, :admin_pwd)}
|
|
)
|
|
|
|
case Plausible.Auth.find_user_by(email: admin_email) do
|
|
nil ->
|
|
{:ok, admin} = Plausible.Auth.create_user(admin_user, admin_email)
|
|
# set the password
|
|
{:ok, admin} = Plausible.Auth.User.set_password(admin, admin_pwd) |> Repo.update()
|
|
# bump-up the trail period
|
|
admin
|
|
|> Ecto.Changeset.cast(%{trial_expiry_date: Timex.today() |> Timex.shift(years: 100)}, [
|
|
:trial_expiry_date
|
|
])
|
|
|> Repo.update()
|
|
|
|
IO.puts("Admin user created successful!")
|
|
|
|
_ ->
|
|
IO.puts("Admin user already exists. I won't override, bailing")
|
|
end
|
|
end
|
|
|
|
def migrate do
|
|
prepare()
|
|
Enum.each(repos(), &run_migrations_for/1)
|
|
prepare_clickhouse()
|
|
run_migrations_for_ch()
|
|
IO.puts("Migrations successful!")
|
|
end
|
|
|
|
def seed do
|
|
prepare()
|
|
# Run seed script
|
|
Enum.each(repos(), &run_seeds_for/1)
|
|
# Signal shutdown
|
|
IO.puts("Success!")
|
|
end
|
|
|
|
def createdb do
|
|
prepare()
|
|
do_create_db()
|
|
prepare_clickhouse(:default_db)
|
|
do_create_ch_db()
|
|
IO.puts("Creation of Db successful!")
|
|
end
|
|
|
|
def rollback do
|
|
prepare()
|
|
|
|
get_step =
|
|
IO.gets("Enter the number of steps: ")
|
|
|> String.trim()
|
|
|> Integer.parse()
|
|
|
|
case get_step do
|
|
{int, _trailing} ->
|
|
Enum.each(repos(), fn repo -> run_rollbacks_for(repo, int) end)
|
|
IO.puts("Rollback successful!")
|
|
|
|
:error ->
|
|
IO.puts("Invalid integer")
|
|
end
|
|
end
|
|
|
|
def configure_ref_inspector() do
|
|
priv_dir = Application.app_dir(:plausible, "priv/ref_inspector")
|
|
Application.put_env(:ref_inspector, :database_path, priv_dir)
|
|
end
|
|
|
|
def configure_ua_inspector() do
|
|
priv_dir = Application.app_dir(:plausible, "priv/ua_inspector")
|
|
Application.put_env(:ua_inspector, :database_path, priv_dir)
|
|
end
|
|
|
|
##############################
|
|
|
|
defp validate_admin({nil, nil, nil}) do
|
|
random_user = :crypto.strong_rand_bytes(8) |> Base.encode64() |> binary_part(0, 8)
|
|
random_pwd = :crypto.strong_rand_bytes(20) |> Base.encode64() |> binary_part(0, 20)
|
|
random_email = "#{random_user}@#{System.get_env("HOST")}"
|
|
IO.puts("generated admin user/password: #{random_email} / #{random_pwd}")
|
|
{random_email, random_user, random_pwd}
|
|
end
|
|
|
|
defp validate_admin({admin_email, admin_user, admin_password}) do
|
|
{admin_email, admin_user, admin_password}
|
|
end
|
|
|
|
defp repos do
|
|
Application.fetch_env!(@app, :ecto_repos)
|
|
end
|
|
|
|
defp run_seeds_for(repo) do
|
|
# Run the seed script if it exists
|
|
seed_script = seeds_path(repo)
|
|
|
|
if File.exists?(seed_script) do
|
|
IO.puts("Running seed script..")
|
|
Code.eval_file(seed_script)
|
|
end
|
|
end
|
|
|
|
defp run_migrations_for(repo) do
|
|
app = Keyword.get(repo.config, :otp_app)
|
|
IO.puts("Running migrations for #{app}")
|
|
{:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
|
|
end
|
|
|
|
defp run_migrations_for_ch() do
|
|
db = Keyword.get(Application.get_env(:plausible, :clickhouse), :database)
|
|
|
|
tb_events = """
|
|
CREATE TABLE IF NOT EXISTS #{db}.events (
|
|
timestamp DateTime,
|
|
name String,
|
|
domain String,
|
|
user_id UInt64,
|
|
session_id UInt64,
|
|
hostname String,
|
|
pathname String,
|
|
referrer String,
|
|
referrer_source String,
|
|
country_code LowCardinality(FixedString(2)),
|
|
screen_size LowCardinality(String),
|
|
operating_system LowCardinality(String),
|
|
browser LowCardinality(String)
|
|
) ENGINE = MergeTree()
|
|
PARTITION BY toYYYYMM(timestamp)
|
|
ORDER BY (name, domain, user_id, timestamp)
|
|
SETTINGS index_granularity = 8192
|
|
"""
|
|
|
|
Clickhousex.query(:clickhouse, tb_events, [])
|
|
|
|
tb_sessions = """
|
|
CREATE TABLE IF NOT EXISTS #{db}.sessions (
|
|
session_id UInt64,
|
|
sign Int8,
|
|
domain String,
|
|
user_id UInt64,
|
|
hostname String,
|
|
timestamp DateTime,
|
|
start DateTime,
|
|
is_bounce UInt8,
|
|
entry_page String,
|
|
exit_page String,
|
|
pageviews Int32,
|
|
events Int32,
|
|
duration UInt32,
|
|
referrer String,
|
|
referrer_source String,
|
|
country_code LowCardinality(FixedString(2)),
|
|
screen_size LowCardinality(String),
|
|
operating_system LowCardinality(String),
|
|
browser LowCardinality(String)
|
|
) ENGINE = CollapsingMergeTree(sign)
|
|
PARTITION BY toYYYYMM(start)
|
|
ORDER BY (domain, user_id, session_id, start)
|
|
SETTINGS index_granularity = 8192
|
|
"""
|
|
|
|
Clickhousex.query(:clickhouse, tb_sessions, [])
|
|
end
|
|
|
|
defp do_create_db do
|
|
for repo <- repos() do
|
|
:ok = ensure_repo_created(repo)
|
|
end
|
|
end
|
|
|
|
defp do_create_ch_db() do
|
|
db_to_create = Keyword.get(Application.get_env(:plausible, :clickhouse), :database)
|
|
IO.puts("create #{inspect(db_to_create)} clickhouse database/tables if it doesn't exist")
|
|
Clickhousex.query(:clickhouse, "CREATE DATABASE IF NOT EXISTS #{db_to_create}", [])
|
|
end
|
|
|
|
defp ensure_repo_created(repo) do
|
|
IO.puts("create #{inspect(repo)} database if it doesn't exist")
|
|
|
|
case repo.__adapter__.storage_up(repo.config) do
|
|
:ok -> :ok
|
|
{:error, :already_up} -> :ok
|
|
{:error, term} -> {:error, term}
|
|
end
|
|
end
|
|
|
|
defp run_rollbacks_for(repo, step) do
|
|
app = Keyword.get(repo.config, :otp_app)
|
|
IO.puts("Running rollbacks for #{app} (STEP=#{step})")
|
|
|
|
{:ok, _, _} =
|
|
Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, all: false, step: step))
|
|
end
|
|
|
|
defp prepare do
|
|
IO.puts("Loading #{@app}..")
|
|
# Load the code for myapp, but don't start it
|
|
:ok = Application.load(@app)
|
|
|
|
IO.puts("Starting dependencies..")
|
|
# Start apps necessary for executing migrations
|
|
Enum.each(@start_apps, &Application.ensure_all_started/1)
|
|
|
|
# Start the Repo(s) for myapp
|
|
IO.puts("Starting repos..")
|
|
Enum.each(repos(), & &1.start_link(pool_size: 2))
|
|
end
|
|
|
|
# connect to the default db for creating the required db
|
|
defp prepare_clickhouse(:default_db) do
|
|
Application.ensure_all_started(:db_connection)
|
|
Application.ensure_all_started(:hackney)
|
|
|
|
Clickhousex.start_link(
|
|
scheme: :http,
|
|
port: 8123,
|
|
name: :clickhouse,
|
|
database: "default",
|
|
username: "default",
|
|
hostname: Keyword.get(Application.get_env(:plausible, :clickhouse), :hostname),
|
|
password: Keyword.get(Application.get_env(:plausible, :clickhouse), :password)
|
|
)
|
|
end
|
|
|
|
defp prepare_clickhouse() do
|
|
Application.ensure_all_started(:db_connection)
|
|
Application.ensure_all_started(:hackney)
|
|
|
|
Clickhousex.start_link(
|
|
scheme: :http,
|
|
port: 8123,
|
|
name: :clickhouse,
|
|
username: Keyword.get(Application.get_env(:plausible, :clickhouse), :username),
|
|
database: Keyword.get(Application.get_env(:plausible, :clickhouse), :database),
|
|
hostname: Keyword.get(Application.get_env(:plausible, :clickhouse), :hostname),
|
|
password: Keyword.get(Application.get_env(:plausible, :clickhouse), :password)
|
|
)
|
|
end
|
|
|
|
defp seeds_path(repo), do: priv_path_for(repo, "seeds.exs")
|
|
|
|
defp priv_path_for(repo, filename) do
|
|
app = Keyword.get(repo.config, :otp_app)
|
|
IO.puts("App: #{app}")
|
|
repo_underscore = repo |> Module.split() |> List.last() |> Macro.underscore()
|
|
Path.join([priv_dir(app), repo_underscore, filename])
|
|
end
|
|
|
|
defp priv_dir(app), do: "#{:code.priv_dir(app)}"
|
|
end
|