[precompilation] add support for multiple NIF versions (#71)

Author: cocoa-xu

PRECOMPILATION_GUIDE.md

@@ -35,10 +35,17 @@ def project do
     # ...
     compilers: [:elixir_make] ++ Mix.compilers(),
     # elixir_make specific config
+    # required
     make_precompiler: {:nif, CCPrecompiler},
     make_precompiler_url: "https://github.com/cocoa-xu/cc_precompiler_example/releases/download/v#{@version}/@{artefact_filename}",
+
+    # optional
     make_precompiler_filename: "nif",
-    make_precompiler_priv_paths: ["nif.*"]
+    make_precompiler_priv_paths: ["nif.*"],
+    make_precompiler_nif_versions: [
+      versions: ["2.14", "2.15", "2.16"],
+      availability: &target_available_for_nif_version?/2
+    ]
     # ...
   ]
 end
@@ -48,9 +55,12 @@ Another required field is `make_precompiler_url`. It is a URL template to the ar
 
 `@{artefact_filename}` in the URL template string will be replaced by corresponding artefact filenames when fetching them. For example, `cc_precompiler_example-nif-2.16-x86_64-linux-gnu-0.1.0.tar.gz`.
 
-Note that there is an optional config key for elixir_make, `make_precompiler_filename`. If the name (file extension does not count) of the shared library is different from your app's name, then `make_precompiler_filename` should be set. For example, if the app name is `"cc_precompiler_example"` while the name shared library is `"nif.so"` (or `"nif.dll"` on windows), then `make_precompiler_filename` should be set as `"nif"`.
+#### `make_precompiler_filename` (optional config key)
+
+The first optional config key for elixir_make is `make_precompiler_filename`. If the name (file extension does not count) of the shared library is different from your app's name, then `make_precompiler_filename` should be set. For example, if the app name is `"cc_precompiler_example"` while the name shared library is `"nif.so"` (or `"nif.dll"` on windows), then `make_precompiler_filename` should be set as `"nif"`.
 
-Another optional config key is `make_precompiler_priv_paths`. For example, say the `priv` directory is organised as follows in Linux, macOS and Windows respectively,
+#### `make_precompiler_priv_paths` (optional config key)
+The second optional config key is `make_precompiler_priv_paths`. For example, say the `priv` directory is organised as follows in Linux, macOS and Windows respectively,
 
 ```
 # Linux
@@ -93,6 +103,30 @@ Of course, wildcards (`?`, `**`, `*`) are supported when specifiying files. For
 
 Directory structures and symbolic links are preserved.
 
+#### `make_precompiler_nif_versions` (optional config key)
+
+The third optional config key is `make_precompiler_nif_versions`. The default value is 
+
+```elixir
+[versions: ["#{:erlang.system_info(:nif_version)}"]]
+```
+
+If you'd like to aim for an older NIF version, say `2.15` for Erlang/OTP 23 and 24, then you need to setup CI correspondingly and set the value of this key to `[versions: ["2.15", "2.16"]]`. This optional key will only be checked when downloading precompiled artefacts.
+
+For some platforms maybe we only have precompiled artefacts after a certain NIF version, say for x86_64 Windows we have precompiled artefacts available when NIF version >= `2.16` while other platforms have precompiled artefacts available from NIF version >= `2.15`.
+
+In such case we can inform `:elixir_make` that Windows targets don't have precompiled artefacts available except for NIF version `2.16` by passing a function to the `availability` sub-key.
+
+```elixir
+defp target_available_for_nif_version?(target, nif_version) do
+  if String.contains?(target, "windows") do
+    nif_version == "2.16"
+  else
+    true
+  end
+end
+```
+
 ### (Optional) Customise Precompilation Targets
 
 To override the default configuration, please set the `cc_precompile` key in `project`. For example,

lib/elixir_make/artefact.ex

@@ -61,14 +61,14 @@ defmodule ElixirMake.Artefact do
   @doc """
   Returns the full path to the precompiled archive.
   """
-  def archive_path(config, target) do
-    Path.join(cache_dir(), archive_filename(config, target))
+  def archive_path(config, target, nif_version) do
+    Path.join(cache_dir(), archive_filename(config, target, nif_version))
   end
 
-  defp archive_filename(config, target) do
+  defp archive_filename(config, target, nif_version) do
     case config[:make_precompiler] do
       {:nif, _} ->
-        "#{config[:app]}-nif-#{:erlang.system_info(:nif_version)}-#{target}-#{config[:version]}.tar.gz"
+        "#{config[:app]}-nif-#{nif_version}-#{target}-#{config[:version]}.tar.gz"
 
       {type, _} ->
         "#{config[:app]}-#{type}-#{target}-#{config[:version]}.tar.gz"
@@ -151,17 +151,43 @@ defmodule ElixirMake.Artefact do
       config[:make_precompiler_url] ||
         Mix.raise("`make_precompiler_url` is not specified in `project`")
 
-    Enum.map(targets, fn target ->
-      archive_filename = archive_filename(config, target)
-      {target, String.replace(url_template, "@{artefact_filename}", archive_filename)}
+    nif_versions =
+      config[:make_precompiler_nif_versions] ||
+        [versions: ["#{:erlang.system_info(:nif_version)}"]]
+
+    Enum.reduce(targets, [], fn target, archives ->
+      archive_filenames =
+        Enum.reduce(nif_versions[:versions], [], fn nif_version, acc ->
+          availability = nif_versions[:availability]
+
+          available? =
+            if is_function(availability, 2) do
+              availability.(target, nif_version)
+            else
+              true
+            end
+
+          if available? do
+            archive_filename = archive_filename(config, target, nif_version)
+
+            [
+              {target, String.replace(url_template, "@{artefact_filename}", archive_filename)}
+              | acc
+            ]
+          else
+            acc
+          end
+        end)
+
+      archive_filenames ++ archives
     end)
   end
 
   @doc """
   Returns the url for the current target.
   """
-  def current_target_url(config, precompiler) do
-    case precompiler.current_target() do
+  def current_target_url(config, precompiler, nif_version) do
+    case precompiler.current_target(nif_version) do
       {:ok, current_target} ->
         available_urls = available_target_urls(config, precompiler)
 

lib/mix/tasks/compile.elixir_make.ex

@@ -205,9 +205,12 @@ defmodule Mix.Tasks.Compile.ElixirMake do
   end
 
   defp download_or_reuse_nif(config, precompiler, app_priv) do
-    case Artefact.current_target_url(config, precompiler) do
+    # should we allow this value to be overwritten by an env var?
+    nif_version = :erlang.system_info(:nif_version)
+
+    case Artefact.current_target_url(config, precompiler, nif_version) do
       {:ok, target, url} ->
-        archived_fullpath = Artefact.archive_path(config, target)
+        archived_fullpath = Artefact.archive_path(config, target, nif_version)
 
         unless File.exists?(archived_fullpath) do
           Mix.shell().info("Downloading precompiled NIF to #{archived_fullpath}")

lib/mix/tasks/elixir_make.checksum.ex

@@ -46,7 +46,7 @@ defmodule Mix.Tasks.ElixirMake.Checksum do
           Artefact.available_target_urls(config, precompiler)
 
         Keyword.get(options, :only_local) ->
-          case Artefact.current_target_url(config, precompiler) do
+          case Artefact.current_target_url(config, precompiler, :erlang.system_info(:nif_version)) do
             {:ok, target, url} ->
               [{target, url}]
 

lib/mix/tasks/elixir_make.precompile.ex

@@ -65,7 +65,7 @@ defmodule Mix.Tasks.ElixirMake.Precompile do
   end
 
   defp create_precompiled_archive(config, target, paths) do
-    archive_path = Artefact.archive_path(config, target)
+    archive_path = Artefact.archive_path(config, target, :erlang.system_info(:nif_version))
 
     Mix.shell().info("Creating precompiled archive: #{archive_path}")
     Mix.shell().info("Paths to archive from priv directory: #{inspect(paths)}")