granicus.if.org Git - ejabberd/blob - mix.exs

   1 defmodule Ejabberd.Mixfile do
   2   use Mix.Project
   3
   4   def project do
   5     [app: :ejabberd,
   6      version: "18.1.0",
   7      description: description(),
   8      elixir: "~> 1.4",
   9      elixirc_paths: ["lib"],
  10      compile_path: ".",
  11      compilers: [:asn1] ++ Mix.compilers,
  12      erlc_options: erlc_options(),
  13      erlc_paths: ["asn1", "src"],
  14      # Elixir tests are starting the part of ejabberd they need
  15      aliases: [test: "test --no-start"],
  16      package: package(),
  17      deps: deps()]
  18   end
  19
  20   def description do
  21     """
  22     Robust, ubiquitous and massively scalable Jabber / XMPP Instant Messaging platform.
  23     """
  24   end
  25
  26   def application do
  27     [mod: {:ejabberd_app, []},
  28      applications: [:ssl, :os_mon],
  29      included_applications: [:lager, :mnesia, :inets, :p1_utils, :cache_tab,
  30                              :fast_tls, :stringprep, :fast_xml, :xmpp,
  31                              :stun, :fast_yaml, :esip, :jiffy, :p1_oauth2,
  32                              :eimp, :fs, :base64url, :jose]
  33                          ++ cond_apps()]
  34   end
  35
  36   defp if_function_exported(mod, fun, arity, okResult) do
  37     :code.ensure_loaded(mod)
  38     if :erlang.function_exported(mod, fun, arity) do
  39       okResult
  40     else
  41       []
  42     end
  43   end
  44
  45   defp erlc_options do
  46     # Use our own includes + includes from all dependencies
  47     includes = ["include"] ++ deps_include(["fast_xml", "xmpp", "p1_utils"])
  48     [:debug_info, {:d, :ELIXIR_ENABLED}] ++ cond_options() ++ Enum.map(includes, fn(path) -> {:i, path} end) ++
  49     if_function_exported(:crypto, :strong_rand_bytes, 1, [{:d, :STRONG_RAND_BYTES}]) ++
  50     if_function_exported(:rand, :uniform, 1, [{:d, :RAND_UNIFORM}]) ++
  51     if_function_exported(:gb_sets, :iterator_from, 2, [{:d, :GB_SETS_ITERATOR_FROM}]) ++
  52     if_function_exported(:public_key, :short_name_hash, 1, [{:d, :SHORT_NAME_HASH}])
  53   end
  54
  55   defp cond_options do
  56     for {:true, option} <- [{config(:graphics), {:d, :GRAPHICS}}], do:
  57     option
  58   end
  59
  60   defp deps do
  61     [{:lager, "~> 3.4.0"},
  62      {:p1_utils, "~> 1.0"},
  63      {:fast_xml, "~> 1.1"},
  64      {:xmpp, "~> 1.1"},
  65      {:cache_tab, "~> 1.0"},
  66      {:stringprep, "~> 1.0"},
  67      {:fast_yaml, "~> 1.0"},
  68      {:fast_tls, "~> 1.0"},
  69      {:stun, "~> 1.0"},
  70      {:esip, "~> 1.0"},
  71      {:p1_mysql, "~> 1.0"},
  72      {:p1_pgsql, "~> 1.1"},
  73      {:jiffy, "~> 0.14.7"},
  74      {:p1_oauth2, "~> 0.6.1"},
  75      {:distillery, "~> 1.0"},
  76      {:ex_doc, ">= 0.0.0", only: :dev},
  77      {:eimp, github: "processone/eimp", ref: "c7201d18"},
  78      {:base64url, "~> 0.0.1"},
  79      {:jose, "~> 1.8"},
  80      {:fs, "~> 3.4"}]
  81     ++ cond_deps()
  82   end
  83
  84   defp deps_include(deps) do
  85     base = case Mix.Project.deps_paths()[:ejabberd] do
  86       nil -> "deps"
  87       _ -> ".."
  88     end
  89     Enum.map(deps, fn dep -> base<>"/#{dep}/include" end)
  90   end
  91
  92   defp cond_deps do
  93     for {:true, dep} <- [{config(:sqlite), {:sqlite3, "~> 1.1"}},
  94                          {config(:riak), {:riakc, "~> 2.4"}},
  95                          {config(:redis), {:eredis, "~> 1.0"}},
  96                          {config(:zlib), {:ezlib, "~> 1.0"}},
  97                          {config(:iconv), {:iconv, "~> 1.0"}},
  98                          {config(:pam), {:epam, "~> 1.0"}},
  99                          {config(:tools), {:luerl, "~> 0.3.1"}},
 100                          {config(:tools), {:meck, "~> 0.8.4"}},
 101                          {config(:tools), {:moka, github: "processone/moka", tag: "1.0.5c"}}], do:
 102       dep
 103   end
 104
 105   defp cond_apps do
 106     for {:true, app} <- [{config(:redis), :eredis},
 107                          {config(:mysql), :p1_mysql},
 108                          {config(:pgsql), :p1_pgsql},
 109                          {config(:sqlite), :sqlite3},
 110                          {config(:zlib), :ezlib},
 111                          {config(:iconv), :iconv}], do:
 112       app
 113   end
 114
 115   defp package do
 116     [# These are the default files included in the package
 117       files: ["lib", "src", "priv", "mix.exs", "include", "README.md", "COPYING"],
 118       maintainers: ["ProcessOne"],
 119       licenses: ["GPLv2"],
 120       links: %{"Site" => "https://www.ejabberd.im",
 121                "Documentation" => "http://docs.ejabberd.im",
 122                "Source" => "https://github.com/processone/ejabberd",
 123                "ProcessOne" => "http://www.process-one.net/"}]
 124   end
 125
 126   defp vars do
 127     case :file.consult("vars.config") do
 128       {:ok,config} -> config
 129       _ -> [zlib: true, iconv: true]
 130     end
 131   end
 132
 133   defp config(key) do
 134     case vars()[key] do
 135       nil -> false
 136       value -> value
 137     end
 138   end
 139
 140 end
 141
 142 defmodule Mix.Tasks.Compile.Asn1 do
 143   use Mix.Task
 144   alias Mix.Compilers.Erlang
 145
 146   @recursive true
 147   @manifest ".compile.asn1"
 148
 149   def run(args) do
 150     {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
 151
 152     project      = Mix.Project.config
 153     source_paths = project[:asn1_paths] || ["asn1"]
 154     dest_paths    = project[:asn1_target] || ["src"]
 155     mappings     = Enum.zip(source_paths, dest_paths)
 156     options      = project[:asn1_options] || []
 157
 158     force = case opts[:force] do
 159         :true -> [force: true]
 160         _ -> [force: false]
 161     end
 162
 163     Erlang.compile(manifest(), mappings, :asn1, :erl, force, fn
 164       input, output ->
 165         options = options ++ [:noobj, outdir: Erlang.to_erl_file(Path.dirname(output))]
 166         case :asn1ct.compile(Erlang.to_erl_file(input), options) do
 167           :ok -> {:ok, :done}
 168           error -> error
 169         end
 170     end)
 171   end
 172
 173   def manifests, do: [manifest()]
 174   defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
 175
 176   def clean, do: Erlang.clean(manifest())
 177 end