Pass migration_source to adapters

Author: josevalim

lib/ecto/adapters/myxql.ex

@@ -227,29 +227,25 @@ defmodule Ecto.Adapters.MyXQL do
   def lock_for_migrations(meta, opts, fun) do
     %{opts: adapter_opts, repo: repo} = meta
 
-    if Keyword.get(adapter_opts, :migration_lock, true) do
-      if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
-        Ecto.Adapters.SQL.raise_migration_pool_size_error()
-      end
+    if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
+      Ecto.Adapters.SQL.raise_migration_pool_size_error()
+    end
 
-      opts = opts ++ [log: false, timeout: :infinity]
+    opts = opts ++ [log: false, timeout: :infinity]
 
-      {:ok, result} =
-        transaction(meta, opts, fn ->
-          lock_name = "\"ecto_#{inspect(repo)}\""
+    {:ok, result} =
+      transaction(meta, opts, fn ->
+        lock_name = "\"ecto_#{inspect(repo)}\""
 
-          try do
-            {:ok, _} = Ecto.Adapters.SQL.query(meta, "SELECT GET_LOCK(#{lock_name}, -1)", [], opts)
-            fun.()
-          after
-            {:ok, _} = Ecto.Adapters.SQL.query(meta, "SELECT RELEASE_LOCK(#{lock_name})", [], opts)
-          end
-        end)
+        try do
+          {:ok, _} = Ecto.Adapters.SQL.query(meta, "SELECT GET_LOCK(#{lock_name}, -1)", [], opts)
+          fun.()
+        after
+          {:ok, _} = Ecto.Adapters.SQL.query(meta, "SELECT RELEASE_LOCK(#{lock_name})", [], opts)
+        end
+      end)
 
-      result
-    else
-      fun.()
-    end
+    result
   end
 
   @impl true

lib/ecto/adapters/postgres.ex

@@ -207,27 +207,23 @@ defmodule Ecto.Adapters.Postgres do
   def lock_for_migrations(meta, opts, fun) do
     %{opts: adapter_opts} = meta
 
-    if Keyword.get(adapter_opts, :migration_lock, true) do
-      if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
-        Ecto.Adapters.SQL.raise_migration_pool_size_error()
-      end
-
-      opts = opts ++ [log: false, timeout: :infinity]
-
-      {:ok, result} =
-        transaction(meta, opts, fn ->
-          # SHARE UPDATE EXCLUSIVE MODE is the first lock that locks
-          # itself but still allows updates to happen, see
-          # # https://www.postgresql.org/docs/9.4/explicit-locking.html
-          source = Keyword.get(adapter_opts, :migration_source, "schema_migrations")
-          {:ok, _} = Ecto.Adapters.SQL.query(meta, "LOCK TABLE \"#{source}\" IN SHARE UPDATE EXCLUSIVE MODE", [], opts)
-          fun.()
-        end)
-
-      result
-    else
-      fun.()
+    if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
+      Ecto.Adapters.SQL.raise_migration_pool_size_error()
     end
+
+    opts = opts ++ [log: false, timeout: :infinity]
+
+    {:ok, result} =
+      transaction(meta, opts, fn ->
+        # SHARE UPDATE EXCLUSIVE MODE is the first lock that locks
+        # itself but still allows updates to happen, see
+        # # https://www.postgresql.org/docs/9.4/explicit-locking.html
+        source = Keyword.get(opts, :migration_source, "schema_migrations")
+        {:ok, _} = Ecto.Adapters.SQL.query(meta, "LOCK TABLE \"#{source}\" IN SHARE UPDATE EXCLUSIVE MODE", [], opts)
+        fun.()
+      end)
+
+    result
   end
 
   @impl true

lib/ecto/adapters/sql.ex

@@ -579,7 +579,7 @@ defmodule Ecto.Adapters.SQL do
     Application.ensure_all_started(driver, type)
   end
 
-  @pool_opts [:timeout, :pool, :pool_size, :migration_lock] ++
+  @pool_opts [:timeout, :pool, :pool_size] ++
                [:queue_target, :queue_interval, :ownership_timeout]
 
   @doc false

lib/ecto/adapters/tds.ex

@@ -280,23 +280,19 @@ defmodule Ecto.Adapters.Tds do
   def lock_for_migrations(meta, opts, fun) do
     %{opts: adapter_opts, repo: repo} = meta
 
-    if Keyword.get(adapter_opts, :migration_lock, true) do
-      if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
-        Ecto.Adapters.SQL.raise_migration_pool_size_error()
-      end
-
-      opts = opts ++ [log: false, timeout: :infinity]
-
-      {:ok, result} =
-        transaction(meta, opts, fn ->
-          lock_name = "'ecto_#{inspect(repo)}'"
-          Ecto.Adapters.SQL.query!(meta, "sp_getapplock @Resource = #{lock_name}, @LockMode = 'Exclusive', @LockOwner = 'Transaction', @LockTimeout = -1", [], opts)
-          fun.()
-        end)
-
-      result
-    else
-      fun.()
+    if Keyword.fetch(adapter_opts, :pool_size) == {:ok, 1} do
+      Ecto.Adapters.SQL.raise_migration_pool_size_error()
     end
+
+    opts = opts ++ [log: false, timeout: :infinity]
+
+    {:ok, result} =
+      transaction(meta, opts, fn ->
+        lock_name = "'ecto_#{inspect(repo)}'"
+        Ecto.Adapters.SQL.query!(meta, "sp_getapplock @Resource = #{lock_name}, @LockMode = 'Exclusive', @LockOwner = 'Transaction', @LockTimeout = -1", [], opts)
+        fun.()
+      end)
+
+    result
   end
 end

lib/ecto/migrator.ex

@@ -477,8 +477,14 @@ defmodule Ecto.Migrator do
 
       {migration_repo, query, all_opts} = SchemaMigration.versions(repo, config, opts[:prefix])
 
+      migration_lock? =
+        Keyword.get(opts, :migration_lock, Keyword.get(config, :migration_lock, true))
+
+      opts =
+        Keyword.put_new(opts, :migration_source, config[:migration_source] || "schema_migrations")
+
       result =
-        if lock_or_migration_number do
+        if lock_or_migration_number && migration_lock? do
           # If there is a migration_repo, it wins over dynamic_repo,
           # otherwise the dynamic_repo is the one locked in migrations.
           meta_repo = if migration_repo != repo, do: migration_repo, else: dynamic_repo

test/ecto/migrator_test.exs

@@ -6,7 +6,6 @@ defmodule Ecto.MigratorTest do
   import ExUnit.CaptureLog
 
   alias EctoSQL.TestRepo
-  alias Ecto.Migration.SchemaMigration
 
   defmodule Migration do
     use Ecto.Migration
@@ -259,14 +258,6 @@ defmodule Ecto.MigratorTest do
     end)
   end
 
-  test "custom schema migrations table is right" do
-    assert {_repo, "schema_migrations"} =
-             SchemaMigration.get_repo_and_source(TestRepo, TestRepo.config())
-
-    assert {_repo, "my_schema_migrations"} =
-             SchemaMigration.get_repo_and_source(MigrationSourceRepo, MigrationSourceRepo.config())
-  end
-
   test "migrator prefix" do
     capture_log(fn ->
       :ok = up(TestRepo, 10, ChangeMigration, prefix: :custom)
@@ -403,6 +394,17 @@ defmodule Ecto.MigratorTest do
       refute_received {:lock_for_migrations, _, _, _}
     end
 
+    test "on migration_source" do
+      assert up(TestRepo, 9, Migration, log: false, migration_source: "custom") == :ok
+      assert_receive {:lock_for_migrations, _, _, opts}
+      assert opts[:migration_source] == "custom"
+    end
+
+    test "on migration_lock" do
+      assert up(TestRepo, 9, Migration, log: false, migration_lock: false) == :ok
+      refute_receive {:lock_for_migrations, _, _, _}
+    end
+
     test "on run" do
       in_tmp fn path ->
         create_migration "13_sample.exs"
@@ -435,8 +437,9 @@ defmodule Ecto.MigratorTest do
         expected_result = [{:up, 15, "sample"}]
         assert migrations(TestRepo, path, skip_table_creation: true) == expected_result
 
-        assert_receive {:lock_for_migrations, _, _, [skip_table_creation: true]}
+        assert_receive {:lock_for_migrations, _, _, opts}
         refute_received {:lock_for_migrations, _, _, _}
+        assert opts[:skip_table_creation] == true
 
         assert match?(nil, last_command())
       end
@@ -449,7 +452,8 @@ defmodule Ecto.MigratorTest do
         expected_result = [{:up, 15, "sample"}]
         assert migrations(TestRepo, path) == expected_result
 
-        assert_receive {:lock_for_migrations, _, _, []}
+        assert_receive {:lock_for_migrations, _, _, opts}
+        assert opts[:migration_source] == "schema_migrations"
         refute_received {:lock_for_migrations, _, _, _}
 
         assert match?({:create_if_not_exists, %_{name: :schema_migrations}, _}, last_command())