├── .formatter.exs
├── .github
    ├── ISSUE_TEMPLATE.md
    └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── .travis.yml
├── Dockerfile.alpine
├── Dockerfile.ubuntu
├── LICENSE.md
├── README.md
├── TODO.md
├── bin
    ├── alpine
    ├── appveyor
    │   └── start-epmd.ps1
    ├── docs
    ├── travis
    └── ubuntu
├── coveralls.json
├── docs
    ├── changelog.md
    ├── config
    │   ├── distillery.md
    │   ├── pidfiles.md
    │   ├── runtime.md
    │   └── vm.args.md
    ├── extensibility
    │   ├── appup_transforms.md
    │   ├── boot_hooks.md
    │   ├── config_providers.md
    │   ├── custom_commands.md
    │   ├── overlays.md
    │   ├── release_plugins.md
    │   └── shell_scripts.md
    ├── faq.md
    ├── guides
    │   ├── appups.md
    │   ├── building_in_docker.md
    │   ├── deploying_to_aws.md
    │   ├── deploying_to_digital_ocean.md
    │   ├── deploying_to_google_cloud_platform.md
    │   ├── phoenix_walkthrough.md
    │   ├── running_migrations.md
    │   ├── systemd.md
    │   ├── upgrades_and_downgrades.md
    │   └── working_with_docker.md
    ├── home.md
    ├── introduction
    │   ├── comparison.md
    │   ├── installation.md
    │   ├── terminology.md
    │   ├── umbrella_projects.md
    │   ├── understanding_releases.md
    │   └── walkthrough.md
    ├── tooling
    │   └── cli.md
    └── upgrading_to_2_0.md
├── lib
    └── distillery
    │   ├── cookies.ex
    │   ├── releases
    │       ├── appup
    │       │   ├── transform.ex
    │       │   ├── transform_error.ex
    │       │   └── utils.ex
    │       ├── appups.ex
    │       ├── archiver.ex
    │       ├── archiver
    │       │   └── archive.ex
    │       ├── assembler.ex
    │       ├── checks.ex
    │       ├── checks
    │       │   ├── cookie.ex
    │       │   ├── erts.ex
    │       │   └── loaded_orphaned_apps.ex
    │       ├── config
    │       │   ├── config.ex
    │       │   ├── load_error.ex
    │       │   ├── provider.ex
    │       │   └── providers
    │       │   │   └── elixir.ex
    │       ├── errors.ex
    │       ├── models
    │       │   ├── app.ex
    │       │   ├── boot_script.ex
    │       │   ├── environment.ex
    │       │   ├── profile.ex
    │       │   └── release.ex
    │       ├── overlays.ex
    │       ├── plugins
    │       │   └── plugin.ex
    │       ├── runtime
    │       │   ├── control.ex
    │       │   └── pidfile.ex
    │       ├── shell.ex
    │       ├── shell
    │       │   └── macros.ex
    │       └── utils.ex
    │   └── tasks
    │       ├── clean.ex
    │       ├── gen.appup.ex
    │       ├── init.ex
    │       └── release.ex
├── mix.exs
├── mix.lock
├── mkdocs.yml
├── priv
    ├── libexec
    │   ├── commands
    │   │   ├── attach.sh
    │   │   ├── command.sh
    │   │   ├── console.sh
    │   │   ├── describe.sh
    │   │   ├── escript.sh
    │   │   ├── eval.sh
    │   │   ├── foreground.sh
    │   │   ├── help.sh
    │   │   ├── info.sh
    │   │   ├── install.sh
    │   │   ├── pid.sh
    │   │   ├── ping.sh
    │   │   ├── pingpeer.sh
    │   │   ├── reboot.sh
    │   │   ├── reload_config.sh
    │   │   ├── remote_console.sh
    │   │   ├── restart.sh
    │   │   ├── rpc.sh
    │   │   ├── start.sh
    │   │   ├── stop.sh
    │   │   ├── unpack.sh
    │   │   └── win
    │   │   │   ├── console.ps1
    │   │   │   ├── describe.ps1
    │   │   │   ├── escript.ps1
    │   │   │   ├── eval.ps1
    │   │   │   ├── foreground.ps1
    │   │   │   ├── help.ps1
    │   │   │   ├── info.ps1
    │   │   │   ├── install.ps1
    │   │   │   ├── ping.ps1
    │   │   │   ├── reboot.ps1
    │   │   │   ├── remote_console.ps1
    │   │   │   ├── restart.ps1
    │   │   │   ├── rpc.ps1
    │   │   │   ├── start.ps1
    │   │   │   ├── stop.ps1
    │   │   │   ├── uninstall.ps1
    │   │   │   └── upgrade.ps1
    │   ├── config.sh
    │   ├── env.sh
    │   ├── erts.sh
    │   ├── helpers.sh
    │   ├── logger.sh
    │   ├── readlink.sh
    │   └── win
    │   │   ├── config.ps1
    │   │   ├── erts.ps1
    │   │   ├── helpers.ps1
    │   │   └── logger.ps1
    └── templates
    │   ├── erl_script.eex
    │   ├── example_config.eex
    │   ├── executable_header.eex
    │   ├── release_rc_entry.eex
    │   ├── release_rc_exec.eex
    │   ├── release_rc_main.eex
    │   ├── release_rc_win_exec.eex
    │   ├── release_rc_win_main.ps1.eex
    │   ├── vm.args.default.eex
    │   └── vm.args.eex
├── requirements.txt
└── test
    ├── cases
        ├── appup_test.exs
        ├── archive_test.exs
        ├── cli_test.exs
        ├── config_test.exs
        ├── cookies_test.exs
        ├── init_test.exs
        ├── integration_test.exs
        ├── integration_test_win32.exs
        ├── overlay_test.exs
        ├── provider_test.exs
        ├── release_test.exs
        ├── shell_test.exs
        ├── test_helper.exs
        └── utils_test.exs
    ├── fixtures
        ├── .gitignore
        ├── appup_beams
        │   ├── test-0.1.0
        │   │   ├── consolidated
        │   │   │   ├── .compile.protocols
        │   │   │   ├── Elixir.Collectable.beam
        │   │   │   ├── Elixir.Enumerable.beam
        │   │   │   ├── Elixir.IEx.Info.beam
        │   │   │   ├── Elixir.Inspect.beam
        │   │   │   ├── Elixir.List.Chars.beam
        │   │   │   ├── Elixir.Poison.Decoder.beam
        │   │   │   ├── Elixir.Poison.Encoder.beam
        │   │   │   ├── Elixir.String.Chars.beam
        │   │   │   ├── Elixir.Timex.Comparable.beam
        │   │   │   └── Elixir.Timex.Convertable.beam
        │   │   └── ebin
        │   │   │   ├── Elixir.Test.Server.beam
        │   │   │   ├── Elixir.Test.Supervisor.beam
        │   │   │   ├── Elixir.Test.beam
        │   │   │   └── test.app
        │   ├── test-0.2.0
        │   │   ├── consolidated
        │   │   │   ├── .compile.protocols
        │   │   │   ├── Elixir.Collectable.beam
        │   │   │   ├── Elixir.Enumerable.beam
        │   │   │   ├── Elixir.IEx.Info.beam
        │   │   │   ├── Elixir.Inspect.beam
        │   │   │   ├── Elixir.List.Chars.beam
        │   │   │   ├── Elixir.Poison.Decoder.beam
        │   │   │   ├── Elixir.Poison.Encoder.beam
        │   │   │   ├── Elixir.String.Chars.beam
        │   │   │   ├── Elixir.Timex.Comparable.beam
        │   │   │   └── Elixir.Timex.Protocol.beam
        │   │   └── ebin
        │   │   │   ├── Elixir.Test.Server.beam
        │   │   │   ├── Elixir.Test.ServerB.beam
        │   │   │   ├── Elixir.Test.ServerC.beam
        │   │   │   ├── Elixir.Test.Supervisor.beam
        │   │   │   ├── Elixir.Test.beam
        │   │   │   └── test.app
        │   ├── test-0.3.0
        │   │   ├── consolidated
        │   │   │   ├── .compile.protocols
        │   │   │   ├── Elixir.Collectable.beam
        │   │   │   ├── Elixir.Enumerable.beam
        │   │   │   ├── Elixir.IEx.Info.beam
        │   │   │   ├── Elixir.Inspect.beam
        │   │   │   ├── Elixir.List.Chars.beam
        │   │   │   ├── Elixir.Poison.Decoder.beam
        │   │   │   ├── Elixir.Poison.Encoder.beam
        │   │   │   ├── Elixir.String.Chars.beam
        │   │   │   ├── Elixir.Timex.Comparable.beam
        │   │   │   └── Elixir.Timex.Protocol.beam
        │   │   └── ebin
        │   │   │   ├── Elixir.Test.Server.beam
        │   │   │   ├── Elixir.Test.ServerB.beam
        │   │   │   ├── Elixir.Test.ServerC.beam
        │   │   │   ├── Elixir.Test.Supervisor.beam
        │   │   │   ├── Elixir.Test.beam
        │   │   │   └── test.app
        │   └── test-appup
        │   │   ├── consolidated
        │   │       ├── .compile.protocols
        │   │       ├── Elixir.Collectable.beam
        │   │       ├── Elixir.Enumerable.beam
        │   │       ├── Elixir.IEx.Info.beam
        │   │       ├── Elixir.Inspect.beam
        │   │       ├── Elixir.List.Chars.beam
        │   │       ├── Elixir.Poison.Decoder.beam
        │   │       ├── Elixir.Poison.Encoder.beam
        │   │       ├── Elixir.String.Chars.beam
        │   │       ├── Elixir.Timex.Comparable.beam
        │   │       └── Elixir.Timex.Protocol.beam
        │   │   ├── ebin
        │   │       ├── Elixir.Test.Server.beam
        │   │       ├── Elixir.Test.ServerB.beam
        │   │       ├── Elixir.Test.ServerC.beam
        │   │       ├── Elixir.Test.Supervisor.beam
        │   │       ├── Elixir.Test.beam
        │   │       └── test.app
        │   │   └── priv
        │   │       └── appups
        │   │           └── 1.0.0_to_2.0.0.appup
        ├── ctrl_app
        │   ├── .formatter.exs
        │   ├── .gitignore
        │   ├── README.md
        │   ├── config
        │   │   └── config.exs
        │   ├── lib
        │   │   └── ctrl_app
        │   │   │   ├── application.ex
        │   │   │   └── worker.ex
        │   └── mix.exs
        ├── files
        │   ├── eval_file_example.exs
        │   ├── simple.config.exs
        │   └── simple.sys.config
        ├── init_test_app
        │   ├── .gitignore
        │   ├── config
        │   │   └── config.exs
        │   ├── init_test_config.eex
        │   ├── lib
        │   │   └── init_test_app.ex
        │   └── mix.exs
        ├── mock_app
        │   ├── invalid_tmpl.eex
        │   ├── rel
        │   │   └── mock_app
        │   │   │   ├── bin
        │   │   │       └── .gitkeep
        │   │   │   ├── erts-7.2
        │   │   │       └── .gitkeep
        │   │   │   ├── lib
        │   │   │       └── .gitkeep
        │   │   │   └── releases
        │   │   │       ├── 0.1.0
        │   │   │           └── .gitkeep
        │   │   │       ├── 0.2.0
        │   │   │           └── .gitkeep
        │   │   │       ├── 0.2.1-1-d3adb3f
        │   │   │           └── .gitkeep
        │   │   │       ├── 0.2.1
        │   │   │           └── .gitkeep
        │   │   │       └── 0.2.2
        │   │   │           └── .gitkeep
        │   └── template_test.eex
        ├── ordered_app
        │   ├── .gitignore
        │   ├── config
        │   │   └── config.exs
        │   ├── lib
        │   │   └── ordered_app.ex
        │   ├── mix.exs
        │   └── rel
        │   │   └── config.exs
        ├── standard_app
        │   ├── .gitignore
        │   ├── config
        │   │   └── config.exs
        │   ├── lib
        │   │   ├── standard_app.ex
        │   │   └── standard_app
        │   │   │   ├── a.ex
        │   │   │   └── b.ex
        │   ├── mix.exs
        │   └── rel
        │   │   ├── config.exs
        │   │   ├── config
        │   │       └── config.exs
        │   │   └── plugins
        │   │       └── env_logger.exs
        └── umbrella_app
        │   ├── .formatter.exs
        │   ├── .gitignore
        │   ├── LICENSE
        │   ├── README.md
        │   ├── apps
        │       └── web
        │       │   ├── .gitignore
        │       │   ├── README.md
        │       │   ├── assets
        │       │       ├── brunch-config.js
        │       │       ├── css
        │       │       │   ├── app.css
        │       │       │   └── phoenix.css
        │       │       ├── js
        │       │       │   ├── app.js
        │       │       │   └── socket.js
        │       │       ├── package-lock.json
        │       │       ├── package.json
        │       │       └── static
        │       │       │   ├── favicon.ico
        │       │       │   ├── images
        │       │       │       └── phoenix.png
        │       │       │   └── robots.txt
        │       │   ├── config
        │       │       ├── config.exs
        │       │       ├── dev.exs
        │       │       ├── prod.exs
        │       │       └── test.exs
        │       │   ├── lib
        │       │       ├── web.ex
        │       │       ├── web
        │       │       │   └── application.ex
        │       │       ├── web_web.ex
        │       │       └── web_web
        │       │       │   ├── channels
        │       │       │       └── user_socket.ex
        │       │       │   ├── controllers
        │       │       │       ├── health_controller.ex
        │       │       │       └── page_controller.ex
        │       │       │   ├── endpoint.ex
        │       │       │   ├── gettext.ex
        │       │       │   ├── router.ex
        │       │       │   ├── templates
        │       │       │       ├── layout
        │       │       │       │   └── app.html.eex
        │       │       │       └── page
        │       │       │       │   └── index.html.eex
        │       │       │   └── views
        │       │       │       ├── error_helpers.ex
        │       │       │       ├── error_view.ex
        │       │       │       ├── layout_view.ex
        │       │       │       └── page_view.ex
        │       │   ├── mix.exs
        │       │   └── priv
        │       │       └── gettext
        │       │           ├── en
        │       │               └── LC_MESSAGES
        │       │               │   └── errors.po
        │       │           └── errors.pot
        │   ├── config
        │       └── config.exs
        │   ├── mix.exs
        │   └── rel
        │       ├── config.exs
        │       ├── config
        │           └── config.exs
        │       ├── plugins
        │           └── .gitignore
        │       └── vm.args
    └── support
        ├── helpers.ex
        ├── integration_case.ex
        ├── io_relay.ex
        ├── purge_transform.ex
        ├── tasks.ex
        └── while.ex


/.formatter.exs:
--------------------------------------------------------------------------------
 1 | [
 2 |   inputs: [
 3 |     "lib/**/*.ex",
 4 |     "test/**/*.{ex, exs}",
 5 |   ],
 6 |   export: [
 7 |     locals_without_parens: [
 8 |       release: 2,
 9 |       environment: 2,
10 |       plugin: 2,
11 |       command: 2,
12 |       command: 3,
13 |       command: 4,
14 |       option: 2,
15 |       option: 3,
16 |       option: 4,
17 |       require_global: 1,
18 |       set: 1
19 |     ]
20 |   ]
21 | ]
22 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | ### Steps to reproduce
 2 | 
 3 | Just a brief list of the steps required to produce the issue.
 4 | 
 5 | ### Verbose Logs
 6 | 
 7 | Paste the output of the release command you ran with the `--verbose` flag
 8 | below in the summary tags (this helps keep the issue easy to navigate):
 9 | 
10 | <summary>
11 |   <details>
12 | 
13 | ```
14 | # Put your logs here!
15 | ```
16 | 
17 |   </details>
18 | </summary>
19 | 
20 | ### Description of issue
21 | 
22 | - What are the expected results?
23 | - What version of Distillery?
24 | - What OS, Erlang/Elixir versions are you seeing this issue on?
25 | - If possible, also provide your `rel/config.exs`, as it is often
26 |   my first troubleshooting question, and you'll save us both time :)
27 | - Is there documentation that says one thing, but Distillery does
28 |   another? If so, please link the doc here so it can be updated if
29 |   it's a documentation issue, or so that the fix can be based around
30 |   what's documented.
31 | - If this is a runtime configuration issue, please also provide your config file 
32 |   (with any sensitive information stripped of course). This is almost
33 |   always necessary to understand why some configuration may not be working.
34 | 
35 | If you do not provide the above information and I need it to help troubleshoot, it may delay things significantly,
36 | as I will have to ask you for all of these things anyway. Help me help you!
37 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | ### Summary of changes
 2 | 
 3 | I'll review the commits, so I mostly want to understand the "why" rather than the "what"
 4 | 
 5 | ### Checklist
 6 | 
 7 | - [ ] New functions have typespecs, changed functions were updated
 8 | - [ ] Same for documentation, including moduledocs
 9 | - [ ] Tests were added or updated to cover changes
10 | - [ ] Commits were squashed into a single coherent commit
11 | 
12 | ### Licensing/Copyright
13 | 
14 | **By submitting this PR, you agree to the following statement, please read before submission!**
15 | 
16 | I certify that I own, and have sufficient rights to contribute, all source code and
17 | related material intended to be compiled or integrated with the source code for Distillery
18 | (the "Contribution"). My Contribution is licensed under the MIT License.
19 | 
20 | NOTE: If you submit a PR and remove the statement above, your PR will be rejected. For your PR to be
21 | considered, it must contain your agreement to license under the MIT license.
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc
12 | 
13 | # If the VM crashes, it generates a dump, let's ignore it too.
14 | erl_crash.dump
15 | 
16 | # Also ignore archive artifacts (built via "mix archive.build").
17 | *.ez
18 | 
19 | .eqc-info
20 | *.eqc
21 | 
22 | /_venv
23 | /bin/parse_releases
24 | /.elixir_ls


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | language: elixir
 3 | git:
 4 |   quiet: true
 5 |   depth: 3
 6 | elixir:
 7 |   - 1.6
 8 |   - 1.7
 9 |   - 1.8
10 | otp_release:
11 |   - 21.0
12 |   - 22.0
13 | matrix:
14 |   exclude:
15 |     - elixir: 1.6
16 |       otp_release: 22.0
17 | env:
18 |   - MIX_ENV=test VERBOSE_TESTS=true
19 | cache:
20 |   directories:
21 |     - _build
22 |     - deps
23 | before_script:
24 |   - epmd -daemon
25 |   - mix do deps.get, eqc.install --mini
26 | script:
27 |   - bin/travis
28 | notifications:
29 |   email:
30 |     - paulschoenfelder@gmail.com
31 | 


--------------------------------------------------------------------------------
/Dockerfile.alpine:
--------------------------------------------------------------------------------
 1 | FROM bitwalker/alpine-elixir:latest
 2 | 
 3 | ENV REFRESHED_AT=2018-08-16
 4 | 
 5 | WORKDIR /opt
 6 | 
 7 | RUN \
 8 |   mkdir -p /opt/distillery && \
 9 |   mkdir -p /opt/distillery-test && \
10 |   mix local.rebar --force && \
11 |   mix local.hex --force && \
12 |   git clone https://github.com/bitwalker/distillery-test
13 | 
14 | CMD ["/bin/bash"]
15 | 


--------------------------------------------------------------------------------
/Dockerfile.ubuntu:
--------------------------------------------------------------------------------
 1 | FROM ubuntu:16.04
 2 | 
 3 | ENV REFRESHED_AT=2018-08-16 \
 4 |     LANG=en_US.UTF-8 \
 5 |     HOME=/opt/app \
 6 |     TERM=xterm
 7 | 
 8 | WORKDIR /opt
 9 | 
10 | RUN \
11 |   mkdir -p /opt/distillery && \
12 |   mkdir -p /opt/distillery-test && \
13 |   apt-get update -y && \
14 |   apt-get install -y git wget vim locales && \
15 |   locale-gen en_US.UTF-8 && \
16 |   wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb && \
17 |   dpkg -i erlang-solutions_1.0_all.deb && \
18 |   apt-get update -y && \
19 |   apt-get install -y erlang elixir && \
20 |   mix local.rebar --force && \
21 |   mix local.hex --force && \
22 |   pushd /opt && \
23 |   git clone https://github.com/bitwalker/distillery-test && \
24 |   popd
25 | 
26 | CMD ["/bin/bash"]
27 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Paul Schoenfelder
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Distillery
 2 | 
 3 | **NOTE:** This project is DEPRECATED. It's functionality was largely integrated into Mix itself
 4 | as part of the Elixir 1.9 release. While there are some small differences between Distillery and
 5 | Mix Releases, the vast majority of users should find it quite easy (and very much worthwhile) to
 6 | migrate. For all others, this repo exists for you to fork and use as you see fit, but it is no
 7 | longer actively maintained. If there are folks interested in taking over maintenance of the project,
 8 | please open an issue and we can coordinate on adding you as a maintainer.
 9 | 
10 | [![Hex.pm Version](http://img.shields.io/hexpm/v/distillery.svg?style=flat)](https://hex.pm/packages/distillery)
11 | 
12 |   * [Documentation](https://hexdocs.pm/distillery)
13 |   * [CHANGELOG](https://hexdocs.pm/distillery/changelog.html)
14 |   * [Upgrading to 2.x](https://hexdocs.pm/distillery/upgrading_to_2_0.html)
15 | 
16 | ## About
17 | 
18 | Every alchemist requires good tools, and one of the greatest tools in the alchemist's disposal
19 | is the distillery. The purpose of the distillery is to take something and break it down to its
20 | component parts, reassembling it into something better, more powerful. That is exactly
21 | what this project does - it takes your Mix project and produces an Erlang/OTP release, a
22 | distilled form of your raw application's components; a single package which can be deployed anywhere,
23 | independently of an Erlang/Elixir installation. No dependencies, no hassle.
24 | 
25 | This is a pure-Elixir, dependency-free implementation of release generation for Elixir projects.
26 | It is currently a standalone package, but may be integrated into Mix at some point in the future.
27 | 
28 | ## Installation
29 | 
30 | Distillery requires Elixir 1.6 or greater. It works with Erlang 20+.
31 | 
32 | ```elixir
33 | defp deps do
34 |   [{:distillery, "~> 2.1"}]
35 | end
36 | ```
37 | 
38 | Just add as a mix dependency and use `mix distillery.release`.
39 | 
40 | If you are new to releases or Distillery, please review the [documentation](https://hexdocs.pm/distillery),
41 | it is extensive and covers just about any question you may have!
42 | 
43 | ## Community/Questions/etc.
44 | 
45 | If you have questions or want to discuss Distillery, releases, or other deployment
46 | related topics, a good starting point is the Deployment section of ElixirForum, which
47 | can be found [here](https://elixirforum.com/c/dedicated-sections/deployment).
48 | 
49 | I can often be found in IRC on freenode, in the `#elixir-lang` channel, and there is
50 | also an [Elixir Slack channel](https://elixir-slackin.herokuapp.com) as well, though I don't frequent that myself, there are
51 | many people who can answer questions there.
52 | 
53 | Failing that, feel free to open an issue on the tracker with questions, and I'll do my
54 | best to get to it in a timely fashion!
55 | 
56 | ## License
57 | 
58 | MIT. See the [`LICENSE.md`](https://github.com/bitwalker/distillery/blob/master/LICENSE.md) in this repository for more details.
59 | 


--------------------------------------------------------------------------------
/TODO.md:
--------------------------------------------------------------------------------
 1 | # TODO
 2 | 
 3 | - [ ] Explore doing config in same VM and use `:init.restart/0` to apply updated
 4 |       arguments and config when booting "for real"
 5 | - [ ] Add documentation for running on Windows
 6 | - [ ] Rewrite batch scripts in Powershell, add test harness for Powershell
 7 |       scripts in Travis
 8 | - [ ] Add documentation for working with NIFs
 9 | - [ ] Try and parse init errors so they can be pretty printed
10 | 


--------------------------------------------------------------------------------
/bin/alpine:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | SCRIPT_DIR="$(dirname "$(dirname "$0")")"
 6 | 
 7 | cd "$SCRIPT_DIR" || exit 1
 8 | 
 9 | if ! docker run --rm -it -v $SCRIPT_DIR:/opt/distillery distillery-alpine:latest; then
10 |     docker build -t distillery-alpine:latest -f "$SCRIPT_DIR"/Dockerfile.alpine .
11 |     docker run --rm -v $SCRIPT_DIR:/opt/distillery -it distillery-alpine:latest
12 | else
13 |     exit 0
14 | fi
15 | 


--------------------------------------------------------------------------------
/bin/appveyor/start-epmd.ps1:
--------------------------------------------------------------------------------
1 | # Locate the epmd executable and start it as a daemon
2 | ls 'C:\Program Files\erl10*' | select-string 'erts-\d+\.\d+\.\d+' | foreach { & (join-path $_ "bin" "epmd.exe") -daemon }
3 | if ($LastExitCode -ne 0) { exit 1 }
4 | 


--------------------------------------------------------------------------------
/bin/docs:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 6 | 
 7 | cd "${SCRIPT_DIR}/.."
 8 | 
 9 | if ! command -v pip >/dev/null; then
10 |     echo "You must have Python and Pip installed to build the docs!"
11 |     exit 2
12 | fi
13 | 
14 | if ! command -v virtualenv >/dev/null; then
15 |     echo "Need virtualenv, but not present, installing.."
16 |     pip install virtualenv
17 | fi
18 | 
19 | if [ ! -d _venv ]; then
20 |     virtualenv _venv
21 | fi
22 | source _venv/bin/activate
23 | pip install -q -r requirements.txt
24 | 
25 | #MIX_ENV=docs mix docs.elixir
26 | 
27 | mkdocs "$@"
28 | 


--------------------------------------------------------------------------------
/bin/travis:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | SKIP_CI=1
 6 | 
 7 | for changed in $(git diff-tree --no-commit-id --name-only -r HEAD); do
 8 |     if [[ "$changed" =~ ^docs/ ]]; then
 9 |         continue
10 |     elif [[ "$changed" =~ ^README ]]; then
11 |         continue
12 |     elif [[ "$changed" =~ ^LICENSE ]]; then
13 |         continue
14 |     elif [[ "$changed" =~ ^TODO ]]; then
15 |         continue
16 |     elif [[ "$changed" =~ ^mkdocs ]]; then
17 |         continue
18 |     elif [[ "$changed" =~ ^requirements ]]; then
19 |         continue
20 |     elif [[ "$changed" =~ ^.github ]]; then
21 |         continue
22 |     elif [[ "$changed" =~ ^bin/ ]]; then
23 |         continue
24 |     elif [[ "$changed" =~ ^Dockerfile ]]; then
25 |         continue
26 |     elif [[ "$changed" =~ ^.appveyor.yml ]]; then
27 |         continue
28 |     else
29 |         SKIP_CI=0
30 |     fi
31 | done
32 | 
33 | if [ $SKIP_CI -eq 0 ]; then
34 |     if mix test --exclude=integration; then
35 |         # Run only non-Windows integration tests
36 |         mix test --only=win32:false
37 |     else
38 |         exit 1
39 |     fi
40 | else
41 |     echo "Only documentation changes, skipping tests.."
42 |     exit 0
43 | fi
44 | 


--------------------------------------------------------------------------------
/bin/ubuntu:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | SCRIPT_DIR="$(dirname "$(dirname "$0")")"
 6 | 
 7 | cd "$SCRIPT_DIR" || exit 1
 8 | 
 9 | if ! docker run --rm -it -v $SCRIPT_DIR:/opt/distillery distillery-ubuntu:latest; then
10 |     docker build -t distillery-ubuntu:latest -f "$SCRIPT_DIR"/Dockerfile.ubuntu .
11 |     docker run --rm -v $SCRIPT_DIR:/opt/distillery -it distillery-ubuntu:latest
12 | else
13 |     exit 0
14 | fi
15 | 


--------------------------------------------------------------------------------
/coveralls.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "custom_stop_words": [
 3 |       "defstruct",
 4 |       "defmacro.+(.+\/\/.+).+do"
 5 |     ],
 6 |     "coverage_options": {
 7 |         "treat_no_relevant_lines_as_covered": true
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/docs/config/pidfiles.md:
--------------------------------------------------------------------------------
 1 | # PID files
 2 | 
 3 | Distillery now has the ability to create a PID file during boot. A PID file is a
 4 | file which contains the PID of the executable which generated it. When an
 5 | application terminates, that file is removed. If it is removed while the
 6 | application is running, the application terminates. If the application restarts,
 7 | a new PID is written to the file.
 8 | 
 9 | These files are used in particular by system supervisors, such as systemd, to
10 | better monitor and interact with the services under their purvey. In general I
11 | recommend using foreground mode when running under systemd, but if you prefer to
12 | run the service as a daemon via start, and have systemd monitor that, PID file
13 | support provides better integration than previous releases.
14 | 
15 | !!! tip
16 |     If you are looking into this because you are using `systemd`, I would
17 |     encourage you to instead define a service unit which leverages the `foreground`
18 |     task, rather than `start`. Not only do you not need a PID file in this case,
19 |     but you get automatic log management via syslog/journalctl. This feature was
20 |     added because that isn't always an option, but if you have the choice, the
21 |     above is a simpler approach.
22 | 
23 | ## Usage
24 | 
25 | To turn on PID file generation, you have two choices:
26 | 
27 |   * Export an environment variable, `PIDFILE="path/to/pidfile"`
28 |   * Set a flag in `vm.args`, `-kernel pidfile '"path/to/pidfile"'`
29 | 
30 | !!! warning
31 |     We need to use two level of quoting, due to how erl parses the command line arguments
32 | 
33 | !!! info
34 |     We use the `kernel` application for this setting because the PID file
35 |     manager process is started as a kernel process, so to access the
36 |     configuration, it must be part of the `kernel` application.
37 | 
38 | If either of these are set, when the PID file manager is started, it will write
39 | the current PID to the given path, and then monitor it for changes. If it
40 | detects that the file has been deleted, then the node is terminated. If asked to
41 | terminate, it will clean up the PID file before doing so.
42 | 
43 | !!! warning
44 |     If you terminate a node brutally, the PID file will remain, since
45 |     our process will never have a chance to execute any cleanup in that case - but
46 |     shutting down that way is not recommended for a variety of reasons, one of which
47 |     is the likelihood of resources being left hanging in the wind. If the PID file
48 |     still exists when the release is restarted, it will be overwritten with the new
49 |     PID, but it may cause some confusion for external processes like systemd.
50 | 


--------------------------------------------------------------------------------
/docs/config/vm.args.md:
--------------------------------------------------------------------------------
 1 | # vm.args
 2 | 
 3 | The `vm.args` file is how one provides configuration for the Erlang VM itself. You can
 4 | also use it to configure applications, but it is generally recommended to use `config.exs`
 5 | or `sys.config` for that instead.
 6 | 
 7 | Distillery will generate a default `vm.args` file for you, which configures the VM for distribution,
 8 | as shown below:
 9 | 
10 | ```
11 | ## Name of the node
12 | -name <%= release_name %>@127.0.0.1
13 | 
14 | ## Cookie for distributed erlang
15 | -setcookie <%= release.profile.cookie %>
16 | 
17 | ## Heartbeat management; auto-restarts VM if it dies or becomes unresponsive
18 | ## (Disabled by default..use with caution!)
19 | ##-heart
20 | 
21 | ## Enable kernel poll and a few async threads
22 | ##+K true
23 | ##+A 5
24 | 
25 | ## Increase number of concurrent ports/sockets
26 | ##-env ERL_MAX_PORTS 4096
27 | 
28 | ## Tweak GC to run more often
29 | ##-env ERL_FULLSWEEP_AFTER 10
30 | 
31 | # Enable SMP automatically based on availability
32 | -smp auto
33 | ```
34 | 
35 | This is templated via EEx, so that we can dynamically set the name and cookie based on configuration.
36 | 
37 | ## Custom Args
38 | 
39 | You can easily provide your own `vm.args` file, either for
40 | the release as a whole, or for a specific environment, via the `vm_args: "path/to/file"` option
41 | in `rel/config.exs`. For example, perhaps you want to generate a `vm.args` which dynamically fetches
42 | the secret cookie or hostname from the environment, but uses the configured release name for the node
43 | name. You can do that like so:
44 | 
45 | 
46 | ```
47 | ## Node name
48 | -name <%= release_name %>@${HOSTNAME}
49 | 
50 | ## Node cookie, used for distribution
51 | -setcookie ${NODE_COOKIE}
52 | ```
53 | 
54 | This will again be templated via EEx, so that `release_name` is replaced with the name of the release,
55 | and you can provide additional variables beyond the defaults via the `:overlay_vars` option in `rel/config.exs`.
56 | 
57 | The `${HOSTNAME}` and `${NODE_COOKIE}` parts will only be dynamically replaced at runtime if you export
58 | `REPLACE_OS_VARS=true` in the system environment prior to starting the release, so be sure you do so if you
59 | want to use this approach.
60 | 
61 | For more information on `vm.args`, please see the documentation on [erl](http://erlang.org/doc/man/erl.html),
62 | specifically the Flags section.
63 | 


--------------------------------------------------------------------------------
/docs/extensibility/appup_transforms.md:
--------------------------------------------------------------------------------
 1 | # Appup transforms
 2 | 
 3 | There are times where you want to automate some change to one or more appups
 4 | programmatically, such as changing the way processes running old code are purged
 5 | (brutal or soft), running a function after a particular application is upgraded,
 6 | and more.
 7 | 
 8 | Distillery provides appup transforms for this purpose. A transform is a module
 9 | which exports two callbacks, `up` and `down`. These callbacks are invoked when
10 | transforming the instruction set for a specific application when upgrading and
11 | downgrading respectively. This transformation happens when building a release.
12 | 
13 | Both `up` and `down` receive the set of instructions to transform, the application
14 | those instructions apply to, the source version, the target version, and the
15 | options given to the transform.
16 | 
17 | ## Configuration
18 | 
19 | You can add a transform to a release as shown below:
20 | 
21 | ```elixir
22 | release :myapp do
23 |   set appup_transforms: [
24 |     {Distillery.Test.SoftPurgeTransform, [default: :brutal_purge, overrides: [test: :soft_purge]]}
25 |   ]
26 | end
27 | ```
28 | 
29 | The transform module shown above is designed to transform the purge mode for all
30 | instructions. It uses the `default` option to specify the purge mode to use for
31 | all instructions, and uses the `overrides` option to allow changing the purge
32 | mode for specific applications.
33 | 
34 | ## Implementation
35 | 
36 | !!! tip
37 |     If you want to see the implementation of the transform shown above, it can
38 |     be found in `test/support/purge_transform.ex` [here](https://github.com/bitwalker/distillery)
39 |     
40 | The implementation of a basic transform looks like so:
41 | 
42 | ```elixir
43 | defmodule MyApp.MyTransform do
44 |   use Distillery.Releases.Appup.Transform
45 |   
46 |   def up(app, _v1, _v2, instructions, opts) do
47 |     # Transform upgrade instructions
48 |   end
49 | 
50 |   def down(app, _v1, _v2, instructions, opts) do
51 |     # Transform downgrade instructions
52 |   end
53 | end
54 | ```
55 | 
56 | !!! warning
57 |     You must ensure that you reverse any actions you perform in either
58 |     direction; in other words, if you change something during an upgrade, you
59 |     must undo that change in the downgrade instructions.
60 |     
61 | !!! warning
62 |     In addition to the warning above, your appups should only execute instructions
63 |     which apply to the Erlang/Elixir code itself - do not execute changes to the
64 |     system environment, run database migrations, or otherwise modify things
65 |     outside the OTP system. The reason for this is simple: the guarantees
66 |     provided by OTP's hot upgrades are only held when restricted to OTP itself, 
67 |     no guarantees can be made about rolling back actions which interact with
68 |     external systems, as they may partially succeed and then fail, at which
69 |     point OTP will roll back the upgrade, but the mutations to the external
70 |     system will remain, which may make break the old version of the code, and
71 |     make a new version more difficult to apply.
72 | 
73 | Distillery does not provide any transforms out of the box, but some may be found
74 | in the Edeliver project.
75 | 


--------------------------------------------------------------------------------
/docs/extensibility/boot_hooks.md:
--------------------------------------------------------------------------------
 1 | # Boot Hooks
 2 | 
 3 | Boot hooks are scripts which execute pre/post to events that occur in the run control script.
 4 | 
 5 | ## Events
 6 | 
 7 | - `pre_configure`, occurs before `REPLACE_OS_VARS` triggers replacement, and before any generated files are generated
 8 | - `post_configure`, ocurrs after environment variable replacement and after generated files are generated
 9 | - `pre_start`, occurs before the release is started
10 | - `post_start`, occurs right after the release is started
11 | - `pre_stop`, occurs after a request to stop the release is issued, but before the release is stopped
12 | - `post_stop`, occurs after the release is stopped
13 | - `pre_upgrade`, occurs before the release is upgraded
14 | - `post_upgrade`, occurs right after the release is upgraded
15 | 
16 | ## Example Usage
17 | 
18 | Given a config like the following:
19 | 
20 | 
21 | ```elixir
22 | use Distillery.Releases.Config
23 | 
24 | environment :default do
25 |   set pre_start_hooks: "rel/hooks/pre_start"
26 |   set post_start_hooks: "rel/hooks/post_start"
27 | end
28 | 
29 | release :myapp do
30 |   set version: current_version(:myapp)
31 | end
32 | ```
33 | 
34 | And the two hook scripts:
35 | 
36 | ```shell
37 | # rel/hooks/pre_start/echo.sh
38 | echo "we're starting!"
39 | ```
40 | 
41 | ```shell
42 | # rel/hooks/post_start/echo.sh
43 | echo "we've started!"
44 | ```
45 | 
46 | When you build your release, and run it, you'll see something
47 | like the following:
48 | 
49 | 
50 | ```
51 | > _build/dev/rel/myapp/bin/myapp foreground
52 | we're starting!
53 | ...snip...
54 | we've started!
55 | ...snip...
56 | ```
57 | 
58 | You have access to anything defined in the run control script environment, see [Shell Scripts](shell_scripts.md) for details.
59 | 


--------------------------------------------------------------------------------
/docs/extensibility/custom_commands.md:
--------------------------------------------------------------------------------
 1 | # Custom Commands
 2 | 
 3 | Custom commands are extensions to the management script, and are used in the same
 4 | way you use `foreground` or `remote_console`, in other words, they have the
 5 | appearance of being part of the release command line interface. Like hooks, they have access to
 6 | the management scripts helper functions and environment.
 7 | 
 8 | ## Example Usage
 9 | 
10 | Given a config like the following:
11 | 
12 | 
13 | ```elixir
14 | use Distillery.Releases.Config
15 | 
16 | environment :default do
17 |   set commands: [
18 |     echo: "rel/commands/echo"
19 |   ]
20 | end
21 | 
22 | release :myapp do
23 |   set version: current_version(:myapp)
24 | end
25 | ```
26 | 
27 | And the command script under `rel/commands/echo`:
28 | 
29 | ```shell
30 | echo "$1"
31 | ```
32 | 
33 | When you build your release, you can then call your command like so:
34 | 
35 | ```
36 | > _build/dev/rel/myapp/bin/myapp echo hi
37 | hi
38 | ```
39 | 
40 | ## Mix Tasks
41 | 
42 | Since Mix Tasks have not been supported in releases, it can feel frustrating to have to write two
43 | interfaces for one task. Distillery now provides tools to make this no longer an issue:
44 | 
45 | First, you should define your Mix task as you would normally. The entry point for your task will
46 | then be something like `Mix.Tasks.MyTask.run/1`.
47 | 
48 | !!! warning
49 |     You can reuse Mix tasks this way, but you must avoid the use of Mix APIs, as they depend on Mix being
50 |     started, as well as having the project context available, which is not the case in releases.
51 | 
52 | Now add a custom command to your release like so:
53 | 
54 | ```elixir
55 | release :myapp do
56 |   set commands: [
57 |     my_task: "rel/commands/my_task"
58 |   ]
59 | end
60 | ```
61 | 
62 | And here's how you invoke your Mix task from the release (in `rel/commands/my_task`):
63 | 
64 | ```shell
65 | #!/usr/bin/env bash
66 | 
67 | release_ctl eval --mfa "Mix.Tasks.MyTask.run/1" --argv -- "$@"
68 | ```
69 | 
70 | Now, when you run `bin/myapp my_task foo bar`, your Mix task will be invoked like so:
71 | 
72 | ```elixir
73 | Mix.Tasks.MyTask.run(["foo", "bar"])
74 | ```
75 | 
76 | That's all there is to it!
77 | 
78 | !!! warning
79 |     You should use `release_remote_ctl rpc` rather than `release_ctl eval` though,
80 |     if your task needs to execute in the context of the running release.
81 | 
82 | You have access to anything defined in the management scripts environment, see
83 | [Shell Scripts](shell_scripts.md) for details.
84 | 


--------------------------------------------------------------------------------
/docs/extensibility/overlays.md:
--------------------------------------------------------------------------------
 1 | # Overlays
 2 | 
 3 | Overlays allow you to modify the contents of the release, you may add/symlink files, create directories,
 4 | and generate files based on templates.
 5 | 
 6 | You may add overlays via your release configuration, e.g:
 7 | 
 8 | ```elixir
 9 | release :myapp do
10 |   ..snip..
11 |   set overlays: [
12 |     {:mkdir, "configs"},
13 |     {:template, "priv/templates/myconfig.eex", "configs/<%= release_name %>.config"}
14 |   ]
15 | end
16 | ```
17 | 
18 | Overlay paths are templated via EEx, with the contents of Distillery-provided overlay vars, including
19 | those you provide via the `overlay_vars` setting. The `template` overlay type assumes the source file is
20 | an EEx template, and generates it using the same overlay vars mentioned above, then copies it to the destination
21 | path provided.
22 | 
23 | All source paths (i.e. those in `copy`, `link`, and `template` overlays) are relative to the project root. All
24 | destination paths (`mkdir` is just a destination path) are relative to the release output directory, which will
25 | be `rel/<release_name>`.
26 | 
27 | Currently, the following overlay vars are provided out of the box by Distillery:
28 | 
29 |   * `release_name` - Name of the release being built
30 | 
31 |   * `release_version` - Version of the release being built
32 | 
33 |   * `is_upgrade` - Is this release an upgrade release
34 | 
35 |   * `upgrade_from` - The version of the release being upgraded from, nil if not an upgrade.
36 | 
37 |   * `dev_mode` - Is this release being built in dev mode
38 | 
39 |   * `include_erts` - Is ERTS being included in the release
40 | 
41 |   * `include_src` - Is source code being included in the release
42 | 
43 |   * `include_system_libs` - Are system libraries being included in the release
44 | 
45 |   * `erl_opts` - The string of options which will be passed to `erl` when running the release
46 | 
47 |   * `run_erl_env` - The string of environment variable assignments which will be applied to
48 |   `run_erl` when running the release
49 | 
50 |   * `erts_vsn` - The current ERTS version
51 | 
52 |   * `output_dir` - The release output directory
53 | 
54 | You may add your own to this list by setting `overlay_vars` to a keyword list of names to values you wish
55 | to make available to templates.
56 | 


--------------------------------------------------------------------------------
/docs/extensibility/release_plugins.md:
--------------------------------------------------------------------------------
 1 | # Release Plugins
 2 | 
 3 | Plugins are how you extend `distillery` itself during release generation. It is worth your time
 4 | to review the module documentation for `Distillery.Releases.Plugin` for more detailed information,
 5 | including an example plugin.
 6 | 
 7 | Plugins can be defined as either a part of your application code, or in Elixir modules contained
 8 | in `.exs` files under `rel/plugins`. The latter will be automatically imported for you so that you
 9 | can reference them in the configuration.
10 | 
11 | You add plugins to a release or environment like so:
12 | 
13 | ```elixir
14 | environment :prod do
15 |   plugin MyApp.ProdPlugin
16 | end
17 | 
18 | release :myapp do
19 |   ..snip..
20 |   plugin MyApp.DoStuff
21 | end
22 | ```
23 | 
24 | Plugins can be configured by passing options to the `plugin` macro:
25 | 
26 | ```elixir
27 | plugin MyApp.AwesomePlugin, foo: 1, bar: 2
28 | ```
29 | 
30 | These plugins are expected to adhere to the `Distillery.Releases.Plugin` behaviour.
31 | 
32 | ### before_assembly
33 | 
34 | Executed prior to the release being assembled. Use this to generate files, etc. before the release
35 | process begins. This callback receives a `Release` struct, fully configured and options.
36 | 
37 | ### after_assembly
38 | 
39 | Executed after the release is assembled in `output_dir`, but prior to being archived. Useful
40 | if you want to manipulate the release in some way after assembly. This callback also receives a
41 | `Release` struct and options.
42 | 
43 | ### before_package
44 | 
45 | Executed just prior to archival of the release. Useful for adding things to the release which are not
46 | trivially done with overlays. This callback also receives a `Release` struct and options.
47 | 
48 | ### after_package
49 | 
50 | Executed after the release has been archived. Useful for doing post-processing type events, i.e. building
51 | a Docker image, etc. Could also be used to automate deployments.
52 | 
53 | ### after_cleanup
54 | 
55 | Executed after a release has been cleaned. Useful if your plugin needs to clean up files which may not
56 | have been removed by the primary clean task. This callback will receive a list of strings, which are the
57 | arguments as passed to `mix clean` on the command line, unprocessed so that you can pass them to `OptionParser` and options.
58 | 


--------------------------------------------------------------------------------
/docs/home.md:
--------------------------------------------------------------------------------
 1 | # Welcome to Distillery's documentation!
 2 | 
 3 | Distillery is a tool for packaging Elixir applications for deployment using
 4 | [OTP releases](http://erlang.org/doc/design_principles/release_structure.html). In
 5 | a nutshell, Distillery produces an artifact, a tarball, which contains your application
 6 | and everything needed to run it. This artifact also contains scripts which allow you to run
 7 | the application in three different modes (console, foreground, and daemonized), as well as
 8 | a variety of utility commands, such as `remote_console` which provides an easy way to connect
 9 | an IEx session to your running application. Releases are more than just a way to package your
10 | application though, and are a core part of Erlang's design, which we inherit in Elixir.
11 | 
12 | To begin, check out the [Installation](introduction/installation.md) page.
13 | 
14 | If you ever feel that a topic is not well covered in these docs, or that content is out of date,
15 | please open an issue [here](https://github.com/bitwalker/distillery).
16 | 


--------------------------------------------------------------------------------
/docs/introduction/comparison.md:
--------------------------------------------------------------------------------
1 | # Coming from other languages
2 | 
3 | TODO
4 | 


--------------------------------------------------------------------------------
/docs/introduction/umbrella_projects.md:
--------------------------------------------------------------------------------
 1 | # Umbrella projects
 2 | 
 3 | Umbrella projects are not much different than regular projects with Distillery, but there are a few
 4 | small difference worth noting.
 5 | 
 6 | The release configuration generated by Distillery under an umbrella project will
 7 | create a default release definition which includes all of the applications in
 8 | the umbrella (which were present at the time you ran `mix distillery.init`). If you
 9 | passed the `--release-per-app` flag, it will generate a separate release
10 | definition for each application.
11 | 
12 | This default behavior is not always desirable, instead you may want to construct
13 | two releases, with different sets of applications in the umbrella, say for a web
14 | frontend, and a processing backend. In this case, you need to modify
15 | `rel/config.exs` with a release definition for each release you want.
16 | 
17 | Extending the example I gave above, using apps named `:web`, `:processing`, and
18 | `:metrics`, you may want two releases, one called `:frontend`, and one called
19 | `:backend`, which contain the relevant application, as well as the standalone
20 | `:metrics` application for monitoring the performance of each node. This would
21 | look like the following in `rel/config.exs`:
22 | 
23 | ```elixir
24 | release :frontend do
25 |   set version: current_version(:web)
26 |   set applications: [:web, :metrics]
27 | end
28 | 
29 | release :backend do
30 |   set version: current_version(:processing)
31 |   set applications: [:processing, :metrics]
32 | end
33 | ```
34 | 
35 | That's all there is to it! You can define many different releases, with arbitrary combinations of applications
36 | as you see fit. To build a named release use `mix distillery.release --name=<release_name>`.
37 | 


--------------------------------------------------------------------------------
/docs/tooling/cli.md:
--------------------------------------------------------------------------------
 1 | # Command line interface
 2 | 
 3 | Distillery is a command-line oriented tool, and has two primary modes of
 4 | interaction. First, via Mix tasks, when working within a Mix project. Secondly,
 5 | via shell scripts, which are part of the generated release, and are the primary
 6 | means by which you interact with that release.
 7 | 
 8 | ## Mix tasks
 9 | 
10 | Distillery provides the following Mix tasks:
11 | 
12 |   * `distillery.init` - for initializing Distillery within a new project
13 |   * `distillery.release` - for building releases
14 |   * `distillery.release.clean` - for cleaning up generated release artifacts
15 |   * `distillery.gen.appup` - for generating appups to use in upgrade releases
16 | 
17 | For more information about these commands and their usage:
18 | 
19 |     $ mix help <task>
20 | 
21 | !!! tip
22 |     If you are building releases as part of your CI/CD pipeline, you may want to use
23 |     the `--warnings-as-errors` flag to the `release` task. This will prevent
24 |     building releases which may fail at runtime from making it through the pipeline.
25 |     **NOTE**: this `--warnings-as-errors` is not the same as the `compile` task `--warnings-as-errors`,
26 |     if you want both, you should run `compile` first, then run `distillery.release`, passing
27 |     the flag to both.
28 | 
29 | ## Release tasks
30 | 
31 | Release tasks are commands given to the shell script which acts as the release
32 | entry point, i.e. the `bin/myapp` script.
33 | 
34 | There are numerous tasks available, you have already seen a few of them:
35 | 
36 |   * `foreground` - run the release in the foreground, like `mix run --no-halt`
37 |   * `console` - run the release with a shell attached, like `iex -S mix`
38 |   * `start` - run the release in the background
39 | 
40 | There are a few other important tasks:
41 | 
42 |   * `stop` - stop a release started via `start`
43 |   * `remote_console` - attach a shell to a running release
44 |   * `describe` - print metadata about the release
45 | 
46 | To see a full listing of tasks available, run `bin/myapp` with no arguments.
47 | 


--------------------------------------------------------------------------------
/lib/distillery/cookies.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Cookies do
 2 |   @moduledoc false
 3 | 
 4 |   @doc """
 5 |   Returns true if the crypto application is available, otherwise false
 6 |   """
 7 |   @spec can_generate_secure_cookie?() :: boolean
 8 |   def can_generate_secure_cookie?, do: match?({:module, _}, Code.ensure_loaded(:crypto))
 9 | 
10 |   @doc """
11 |   Gets a new cookie for the current project.
12 |   """
13 |   @spec get() :: atom
14 |   def get do
15 |     if can_generate_secure_cookie?() do
16 |       generate()
17 |     else
18 |       # When the :crypto module is unavailable, rather than generating
19 |       # a cookie guessable by a computer, produce this obviously
20 |       # insecure cookie. A warning will be emitted every time
21 |       # it is used (i.e. when vm.args is being generated with it).
22 |       :insecure_cookie_in_distillery_config
23 |     end
24 |   end
25 | 
26 |   @doc """
27 |   Generates a secure cookie based on `:crypto.strong_rand_bytes/1`.
28 |   """
29 |   @spec generate() :: atom
30 |   def generate do
31 |     Stream.unfold(nil, fn _ -> {:crypto.strong_rand_bytes(1), nil} end)
32 |     |> Stream.filter(fn <<b>> -> b >= ?! && b <= ?~ end)
33 |     # special when erlexec parses vm.args
34 |     |> Stream.reject(fn <<b>> -> b in [?-, ?+, ?', ?\", ?\\, ?\#, ?,] end)
35 |     |> Enum.take(64)
36 |     |> Enum.join()
37 |     |> String.to_atom()
38 |   end
39 | end
40 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/appup/transform_error.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Appup.TransformError do
 2 |   @moduledoc """
 3 |   This error is raised when an appup transformation results in an
 4 |   invalid appup instruction or instruction set.
 5 |   """
 6 |   defexception [:message, :module, :callback]
 7 | 
 8 |   @doc false
 9 |   def exception(opts) do
10 |     m = Keyword.fetch!(opts, :module)
11 |     cb = Keyword.fetch!(opts, :callback)
12 | 
13 |     case Keyword.fetch!(opts, :error) do
14 |       {:invalid_instruction, :restart_new_emulator} ->
15 |         msg =
16 |           "The appup transformation #{m}.#{cb}/5 incorrectly " <>
17 |             "placed :restart_new_emulator which must always be the first instruction"
18 | 
19 |         %__MODULE__{message: msg, module: m, callback: cb}
20 | 
21 |       {:invalid_instruction, :restart_emulator} ->
22 |         msg =
23 |           "The appup transformation #{m}.#{cb}/5 incorrectly " <>
24 |             "placed :restart_emulator which must always be the last instruction"
25 | 
26 |         %__MODULE__{message: msg, module: m, callback: cb}
27 | 
28 |       {:invalid_instruction, i} ->
29 |         msg =
30 |           "The appup transformation #{m}.#{cb}/5 generated an invalid instruction " <>
31 |             "(#{inspect(i)}).\n" <>
32 |             "Please review http://erlang.org/doc/design_principles/release_handling.html for a listing of valid instructions"
33 | 
34 |         %__MODULE__{message: msg, module: m, callback: cb}
35 | 
36 |       {:invalid_return, val} ->
37 |         msg =
38 |           "The appup transformation #{m}.#{cb}/5 returned an invalid value.\n" <>
39 |             "  Expected a list of appup instructions, but got: #{inspect(val)}"
40 | 
41 |         %__MODULE__{message: msg, module: m, callback: cb}
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/checks.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Checks do
 2 |   @moduledoc """
 3 |   This module defines a behavior for, and orchestrator of, static analysis checks
 4 |   to be performed at release-time. These checks are intended to operate on the fully
 5 |   reified release configuration and metadata, and return warnings, errors, or ok for
 6 |   the release assembler to react to.
 7 | 
 8 |   In most cases, warnings will be printed but assembly will continue; errors will be
 9 |   printed but will terminate assembly, and a successful check will be printed only if
10 |   verbose logging is enabled.
11 |   """
12 |   alias Distillery.Releases.Release
13 | 
14 |   @callback run(Release.t()) :: :ok | {:ok, warning :: String.t()} | {:error, term}
15 | 
16 |   defmacro __using__(_) do
17 |     quote do
18 |       @behaviour unquote(__MODULE__)
19 | 
20 |       alias unquote(__MODULE__)
21 |     end
22 |   end
23 | 
24 |   @type warning :: String.t()
25 | 
26 |   # The default set of checks to run when executing validate_configuration/1
27 |   @default_checks [
28 |     __MODULE__.Erts,
29 |     __MODULE__.Cookie,
30 |     __MODULE__.LoadedOrphanedApps
31 |   ]
32 | 
33 |   @doc """
34 |   Returns a list of all checks available to be applied.
35 |   """
36 |   def list() do
37 |     extra = Application.get_env(:distillery, :extra_checks, [])
38 |     Enum.concat(@default_checks, extra)
39 |   end
40 | 
41 |   @doc """
42 |   Runs all default and configured checks against the given release.
43 |   """
44 |   @spec run(Release.t()) :: :ok | {:error, term}
45 |   def run(%Release{} = release) do
46 |     Distillery.Releases.Shell.debug("Running validation checks..")
47 |     run(list(), release)
48 |   end
49 | 
50 |   @doc """
51 |   Runs all of the given checks, in the given order.
52 |   """
53 |   @spec run([module], Release.t()) :: :ok | {:error, term}
54 |   def run([], _release),
55 |     do: :ok
56 | 
57 |   def run(checks, release),
58 |     do: do_run(checks, release, [])
59 | 
60 |   defp do_run([], _release, warnings) do
61 |     for warning <- Enum.reverse(warnings) do
62 |       Distillery.Releases.Shell.notice(warning)
63 |     end
64 | 
65 |     :ok
66 |   end
67 | 
68 |   defp do_run([check | checks], %Release{} = release, warnings) do
69 |     Distillery.Releases.Shell.debugf("    > #{Enum.join(Module.split(check), ".")}")
70 | 
71 |     case check.run(release) do
72 |       :ok ->
73 |         Distillery.Releases.Shell.debugf(" * PASS\n", :green)
74 |         do_run(checks, release, warnings)
75 | 
76 |       {:ok, warning} when is_binary(warning) ->
77 |         Distillery.Releases.Shell.debugf(" * WARN\n\n", :yellow)
78 |         do_run(checks, release, [warning | warnings])
79 | 
80 |       {:error, _} = err ->
81 |         Distillery.Releases.Shell.debugf(" * FAILED\n", :red)
82 | 
83 |         for warning <- Enum.reverse(warnings) do
84 |           Distillery.Releases.Shell.notice(warning)
85 |         end
86 | 
87 |         err
88 | 
89 |       other ->
90 |         {:error,
91 |          "The check #{__MODULE__} returned #{inspect(other)} " <>
92 |            "when :ok, {:ok, String.t}, or {:error term} were expected"}
93 |     end
94 |   end
95 | end
96 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/checks/cookie.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Checks.Cookie do
 2 |   @moduledoc """
 3 |   Runs some basic validation of the distribution cookie configuration
 4 |   """
 5 |   use Distillery.Releases.Checks
 6 | 
 7 |   alias Distillery.Releases.Release
 8 |   alias Distillery.Releases.Profile
 9 | 
10 |   def run(%Release{profile: %Profile{cookie: nil}}) do
11 |     warning =
12 |       "Attention! You did not provide a cookie for the erlang distribution protocol in rel/config.exs\n" <>
13 |         "    For backwards compatibility, the release name will be used as a cookie, which is potentially a security risk!\n" <>
14 |         "    Please generate a secure cookie and use it with `set cookie: <cookie>` in rel/config.exs.\n" <>
15 |         "    This will be an error in a future release."
16 | 
17 |     {:ok, warning}
18 |   end
19 | 
20 |   def run(%Release{profile: %Profile{cookie: cookie}}) when is_atom(cookie) do
21 |     if String.contains?(Atom.to_string(cookie), "insecure") do
22 |       warning =
23 |         "Attention! You have an insecure cookie for the erlang distribution protocol in rel/config.exs\n" <>
24 |           "    This is probably because a secure cookie could not be auto-generated.\n" <>
25 |           "    Please generate a secure cookie and use it with `set cookie: <cookie>` in rel/config.exs."
26 | 
27 |       {:ok, warning}
28 |     else
29 |       :ok
30 |     end
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/checks/erts.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Checks.Erts do
 2 |   @moduledoc """
 3 |   Validates the ERTS configuration for the given release
 4 |   """
 5 |   use Distillery.Releases.Checks
 6 | 
 7 |   alias Distillery.Releases.Release
 8 |   alias Distillery.Releases.Profile
 9 |   alias Distillery.Releases.Utils
10 | 
11 |   def run(%Release{profile: %Profile{dev_mode: dev_mode, include_erts: include_erts}}) do
12 |     with :ok <- Utils.validate_erts(include_erts) do
13 |       # Warn if not including ERTS when not obviously running in a dev configuration
14 |       if dev_mode == false and include_erts == false do
15 |         {:ok,
16 |          "IMPORTANT: You have opted to *not* include the Erlang runtime system (ERTS).\n" <>
17 |            "You must ensure that the version of Erlang this release is built with matches\n" <>
18 |            "the version the release will be run with once deployed. It will fail to run otherwise."}
19 |       else
20 |         :ok
21 |       end
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/config/load_error.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Config.LoadError do
 2 |   @moduledoc false
 3 |   defexception [:file, :error]
 4 | 
 5 |   def message(%__MODULE__{file: file, error: error}) do
 6 |     "could not load release config #{Path.relative_to_cwd(file)}\n    " <>
 7 |       "#{Exception.format_banner(:error, error)}"
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/config/providers/elixir.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Config.Providers.Elixir do
 2 |   @moduledoc """
 3 |   Provides support for `Mix.Config` config scripts, e.g. `config.exs`
 4 | 
 5 |   This provider expects a path to a config file to load during boot as an argument:
 6 | 
 7 |       set config_providers: [
 8 |         {Distillery.Releases.Config.Providers.Elixir, ["${RELEASE_ROOT_DIR}/config.exs"]}
 9 |       ]
10 | 
11 |   The above configuration goes in a `release` or `environment` definition in `rel/config.exs`,
12 |   and will result in the given path being expanded during boot, and evaluated using `Mix.Config`.
13 | 
14 |   ## Caveats
15 | 
16 |   Because much of Mix assumes it is operating in a Mix project context, there are some things you
17 |   need to be aware of when using `Mix.Config` in releases:
18 | 
19 |     * `Mix` APIs, other than `Mix.Config` itself, are not guaranteed to work, and most do not. This
20 |       provider starts Mix when the provider runs, so you can call `Mix.env`, but it is an exception
21 |       to the rule. Other functions are unlikely to work, so you should not rely on them being available.
22 |     * `Mix.env` always returns `:prod`, unless `MIX_ENV` is exported in the environment, in which case
23 |       that value is used instead.
24 |     * The Mix project context is unavailable, as is your build environment, so Mix configs which invoke
25 |       `git` or otherwise depend on that context, are not going to work. You need to use configs which are
26 |       pared down to only reference the target environment (in general configs should be small anyway).
27 |   """
28 | 
29 |   use Distillery.Releases.Config.Provider
30 | 
31 |   @impl Provider
32 |   def init([path]) do
33 |     # Start Mix if not started to allow calling Mix APIs
34 |     started? = List.keymember?(Application.started_applications(), :mix, 0)
35 | 
36 |     unless started? do
37 |       :ok = Application.start(:mix)
38 |       # Always set MIX_ENV to :prod, unless otherwise given
39 |       env = System.get_env("MIX_ENV") || "prod"
40 |       System.put_env("MIX_ENV", env)
41 |       Mix.env(String.to_atom(env))
42 |     end
43 | 
44 |     try do
45 |       with {:ok, path} <- Provider.expand_path(path) do
46 |         path
47 |         |> eval!()
48 |         |> merge_config()
49 |         |> Mix.Config.persist()
50 |       else
51 |         {:error, reason} ->
52 |           exit(reason)
53 |       end
54 |     else
55 |       _ ->
56 |         :ok
57 |     after
58 |       unless started? do
59 |         # Do not leave Mix started if it was started here
60 |         # The boot script needs to be able to start it
61 |         :ok = Application.stop(:mix)
62 |       end
63 |     end
64 |   end
65 | 
66 |   def merge_config(runtime_config) do
67 |     Enum.flat_map(runtime_config, fn {app, app_config} ->
68 |       all_env = Application.get_all_env(app)
69 |       Mix.Config.merge([{app, all_env}], [{app, app_config}])
70 |     end)
71 |   end
72 | 
73 |   @doc false
74 |   def eval!(path, imported_paths \\ [])
75 | 
76 |   Code.ensure_loaded(Mix.Config)
77 | 
78 |   if function_exported?(Mix.Config, :eval!, 2) do
79 |     def eval!(path, imported_paths) do
80 |       {config, _} = Mix.Config.eval!(path, imported_paths)
81 |       config
82 |     end
83 |   else
84 |     def eval!(path, imported_paths), do: Mix.Config.read!(path, imported_paths)
85 |   end
86 | end
87 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/models/app.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.App do
 2 |   @moduledoc """
 3 |   Represents important metadata about a given application.
 4 |   """
 5 |   defstruct name: nil,
 6 |             vsn: nil,
 7 |             applications: [],
 8 |             included_applications: [],
 9 |             start_type: nil,
10 |             path: nil
11 | 
12 |   @type start_type :: :permanent | :temporary | :transient | :load | :none
13 |   @type t :: %__MODULE__{
14 |           name: atom(),
15 |           vsn: String.t(),
16 |           applications: [atom()],
17 |           included_applications: [atom()],
18 |           start_type: start_type,
19 |           path: nil | String.t()
20 |         }
21 | 
22 |   @valid_start_types [:permanent, :temporary, :transient, :load, :none]
23 | 
24 |   @doc """
25 |   Create a new Application struct from an application name
26 |   """
27 |   @spec new(atom) :: nil | __MODULE__.t() | {:error, String.t()}
28 |   def new(name),
29 |     do: do_new(name, nil)
30 | 
31 |   @doc """
32 |   Same as new/1, but specify the application's start type
33 |   """
34 |   @spec new(atom, start_type | nil) :: nil | __MODULE__.t() | {:error, String.t()}
35 |   def new(name, start_type) when is_atom(name) and start_type in @valid_start_types,
36 |     do: do_new(name, start_type)
37 | 
38 |   def new(name, nil) when is_atom(name),
39 |     do: do_new(name, nil)
40 | 
41 |   def new(name, start_type) do
42 |     {:error, {:apps, {:invalid_start_type, name, start_type}}}
43 |   end
44 | 
45 |   defp do_new(name, start_type) do
46 |     _ = Application.load(name)
47 | 
48 |     case Application.spec(name) do
49 |       nil ->
50 |         nil
51 | 
52 |       spec ->
53 |         vsn = '#{Keyword.get(spec, :vsn)}'
54 |         apps = Keyword.get(spec, :applications, [])
55 |         included = Keyword.get(spec, :included_applications, [])
56 |         path = Application.app_dir(name)
57 | 
58 |         %__MODULE__{
59 |           name: name,
60 |           vsn: vsn,
61 |           start_type: start_type,
62 |           applications: apps,
63 |           included_applications: included,
64 |           path: path
65 |         }
66 |     end
67 |   end
68 | 
69 |   @doc """
70 |   Determines if the provided start type is a valid one.
71 |   """
72 |   @spec valid_start_type?(atom) :: boolean()
73 |   def valid_start_type?(start_type) when start_type in @valid_start_types, do: true
74 | 
75 |   def valid_start_type?(_), do: false
76 | end
77 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/models/environment.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Environment do
 2 |   @moduledoc """
 3 |   Represents a unique configuration for releases built in this environment.
 4 |   """
 5 |   alias Distillery.Releases.Profile
 6 | 
 7 |   defstruct name: :default,
 8 |             profile: nil
 9 | 
10 |   @type t :: %__MODULE__{
11 |           name: atom(),
12 |           profile: Profile.t()
13 |         }
14 | 
15 |   @doc """
16 |   Creates a new Environment with the given name
17 |   """
18 |   @spec new(atom()) :: t()
19 |   def new(name) when is_atom(name),
20 |     do: %__MODULE__{name: name, profile: %Profile{}}
21 | end
22 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/runtime/pidfile.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Runtime.Pidfile do
 2 |   @moduledoc """
 3 |   This is a kernel process which will maintain a pidfile for the running node
 4 |   """
 5 | 
 6 |   @doc false
 7 |   # Will be called by `:init`
 8 |   def start() do
 9 |     # We don't need to link to `:init`, it will take care
10 |     # of linking to us, since we're being started as a kernel process
11 |     pid = spawn(__MODULE__, :init, [self(), Process.whereis(:init)])
12 | 
13 |     receive do
14 |       {:ok, ^pid} = ok ->
15 |         ok
16 | 
17 |       {:ignore, ^pid} ->
18 |         :ignore
19 | 
20 |       {:error, ^pid, reason} ->
21 |         {:error, reason}
22 |     end
23 |   end
24 | 
25 |   @doc false
26 |   def init(starter, parent) do
27 |     me = self()
28 | 
29 |     case Application.get_env(:kernel, :pidfile, System.get_env("PIDFILE")) do
30 |       nil ->
31 |         # No config, so no need for this process
32 |         send(starter, {:ignore, me})
33 | 
34 |       path when is_binary(path) or is_list(path) ->
35 |         pid = :os.getpid()
36 |         case :prim_file.write_file(path, List.to_string(pid)) do
37 |           :ok ->
38 |             # We've written the pid, so proceed
39 |             Process.flag(:trap_exit, true)
40 | 
41 |             # Register
42 |             Process.register(me, __MODULE__)
43 | 
44 |             # We're started!
45 |             send(starter, {:ok, me})
46 | 
47 |             # Enter receive loop
48 |             loop(%{pidfile: path}, starter, parent)
49 | 
50 |           {:error, reason} ->
51 |             send(starter, {:error, me, {:invalid_pidfile, path, reason}})
52 |         end
53 | 
54 |       path ->
55 |         send(starter, {:error, me, {:invalid_pidfile_config, path}})
56 |     end
57 |   end
58 | 
59 |   defp loop(%{pidfile: path} = state, starter, parent) do
60 |     receive do
61 |       {:EXIT, pid, reason} when pid in [starter, parent] ->
62 |         # Cleanup pidfile
63 |         _ = :prim_file.delete(path)
64 |         exit(reason)
65 | 
66 |       _ ->
67 |         loop(state, starter, parent)
68 |     after
69 |       5_000 ->
70 |         if exists?(path) do
71 |           loop(state, starter, parent)
72 |         else
73 |           :init.stop()
74 |         end
75 |     end
76 |   end
77 | 
78 |   defp exists?(path) do
79 |     case :prim_file.read_file_info(path) do
80 |       {:error, _} ->
81 |         false
82 |       {:ok, _info} ->
83 |         true
84 |     end
85 |   end
86 | end
87 | 


--------------------------------------------------------------------------------
/lib/distillery/releases/shell.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Releases.Shell do
 2 |   @moduledoc """
 3 |   This module provides conveniences for writing output to the shell.
 4 |   """
 5 |   use Distillery.Releases.Shell.Macros
 6 | 
 7 |   @type verbosity :: :silent | :quiet | :normal | :verbose
 8 |   # The order of these levels is from least important to most important
 9 |   # When comparing log levels with `gte`, this ordering is what determines their total ordering
10 |   deflevel(:debug, prefix: "==> ", color: :cyan)
11 |   deflevel(:info, prefix: "==> ", color: [:bright, :cyan])
12 |   deflevel(:notice, color: :yellow)
13 |   deflevel(:success, prefix: "==> ", color: [:bright, :green])
14 |   deflevel(:warn, prefix: "==> ", color: :yellow, error: :warnings_as_errors)
15 |   deflevel(:error, prefix: "==> ", color: :red)
16 | 
17 |   @doc """
18 |   Configure the logging verbosity of the release logger.
19 | 
20 |   Valid verbosity settings are:
21 | 
22 |       * `:silent`  - no output except errors
23 |       * `:quiet`   - no output except warnings/errors
24 |       * `:normal`  - no debug output (default)
25 |       * `:verbose` - all output
26 |   """
27 |   @spec configure(verbosity) :: :ok
28 |   def configure(verbosity) when is_atom(verbosity) do
29 |     Application.put_env(:mix, :release_logger_verbosity, verbosity)
30 |   end
31 | 
32 |   @default_answer_pattern ~r/^(y(es)?)?$/i
33 | 
34 |   @doc """
35 |   Ask the user to confirm an action using the given message.
36 |   The confirmation prompt will default to "[Yn]: ", and the
37 |   regex for determining whether the action was confirmed will
38 |   default to #{inspect(Regex.source(@default_answer_pattern))}.
39 | 
40 |   Use confirm/3 to provide your own prompt and answer regex.
41 |   """
42 |   @spec confirm?(String.t()) :: boolean
43 |   def confirm?(message) do
44 |     confirm?(message, "[Yn]: ", @default_answer_pattern)
45 |   end
46 | 
47 |   @doc """
48 |   Same as confirm/1, but takes a custom prompt and answer regex pattern.
49 |   If the pattern matches the response, the action is considered confirmed.
50 |   """
51 |   @spec confirm?(String.t(), String.t(), Regex.t()) :: boolean
52 |   def confirm?(message, prompt, answer_pattern) do
53 |     IO.puts(IO.ANSI.format([:yellow]))
54 |     answer = IO.gets("#{message} #{prompt}") |> String.trim_trailing("\n")
55 |     IO.puts(IO.ANSI.format([:reset]))
56 |     answer =~ answer_pattern
57 |   end
58 | 
59 |   @doc """
60 |   Prints an error message, then terminates the VM with a non-zero status code
61 |   """
62 |   @spec fail!(iodata) :: no_return
63 |   def fail!(message) do
64 |     error(message)
65 |     System.halt(1)
66 |   end
67 | 
68 |   @doc "Write the given iodata directly, bypassing the log level"
69 |   def write(message),
70 |     do: IO.write(message)
71 | 
72 |   @doc "Write the given iodata, wrapped in the given color, but bypassing the log level"
73 |   def writef(message, color),
74 |     do: write(colorf(message, color))
75 | 
76 |   @doc "Write a debug level message, but with minimal formatting. Default color is same as debug level"
77 |   def debugf(message, color \\ :cyan) do
78 |     data = verbosityf(:debug, colorf(message, color))
79 |     IO.write(data)
80 |   end
81 | 
82 |   ## Color helpers
83 | 
84 |   # Formats a message with a given color
85 |   # Can use shorthand atoms for colors, or pass the ANSI directly
86 |   @doc """
87 |   Wraps a message in the given color
88 |   """
89 |   def colorf(message, color), do: IO.ANSI.format([color, message, :reset])
90 | end
91 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
  1 | defmodule Distillery.Mixfile do
  2 |   use Mix.Project
  3 | 
  4 |   def project do
  5 |     [
  6 |       app: :distillery,
  7 |       version: "2.1.1",
  8 |       elixir: "~> 1.6",
  9 |       build_embedded: Mix.env() == :prod,
 10 |       start_permanent: Mix.env() == :prod,
 11 |       deps: deps(),
 12 |       description: description(),
 13 |       package: package(),
 14 |       docs: docs(),
 15 |       aliases: aliases(),
 16 |       elixirc_paths: elixirc_paths(Mix.env),
 17 |       preferred_cli_env: [
 18 |         docs: :docs,
 19 |         "hex.publish": :docs,
 20 |         "eqc.install": :test,
 21 |         coveralls: :test,
 22 |         "coveralls.detail": :test,
 23 |         "coveralls.html": :test,
 24 |         "coveralls.json": :test,
 25 |         "coveralls.post": :test,
 26 |       ],
 27 |       test_coverage: [tool: ExCoveralls],
 28 |       test_paths: ["test/cases"],
 29 |       dialyzer_warnings: [
 30 |         :error_handling,
 31 |         :race_conditions,
 32 |         :underspecs,
 33 |         :unknown
 34 |       ],
 35 |       dialyzer_ignored_warnings: [
 36 |         {:warn_contract_supertype, :_, {:contract_supertype, [:_, :impl_for, 1, :_, :_]}},
 37 |         {:warn_contract_supertype, :_, {:contract_supertype, [:_, :impl_for!, 1, :_, :_]}}
 38 |       ]
 39 |     ]
 40 |   end
 41 | 
 42 |   def application do
 43 |     [extra_applications: [:runtime_tools]]
 44 |   end
 45 | 
 46 |   defp deps do
 47 |     [
 48 |       {:artificery, "~> 0.2"},
 49 |       {:ex_doc, "~> 0.13", only: [:docs]},
 50 |       {:excoveralls, "~> 0.6", only: [:test]},
 51 |       {:eqc_ex, "~> 1.4", only: [:test]},
 52 |       {:ex_unit_clustered_case, "~> 0.3", only: [:test], runtime: false},
 53 |       {:dialyzex, "~> 1.2", only: [:dev], runtime: false}
 54 |     ]
 55 |   end
 56 | 
 57 |   defp description do
 58 |     """
 59 |     Build releases of your Mix projects with ease!
 60 |     """
 61 |   end
 62 | 
 63 |   defp package do
 64 |     [
 65 |       files: ["lib", "priv", "mix.exs", "README.md", "LICENSE.md", ".formatter.exs"],
 66 |       maintainers: ["Paul Schoenfelder"],
 67 |       licenses: ["MIT"],
 68 |       links: %{
 69 |         Documentation: "https://hexdocs.pm/distillery",
 70 |         Changelog: "https://hexdocs.pm/distillery/changelog.html",
 71 |         GitHub: "https://github.com/bitwalker/distillery"
 72 |       }
 73 |     ]
 74 |   end
 75 | 
 76 |   defp aliases do
 77 |     [
 78 |       docs: [&mkdocs/1, "docs"],
 79 |       c: ["compile", "format --check-equivalent"],
 80 |       "compile-check": [
 81 |         "compile",
 82 |         "format --check-formatted --dry-run",
 83 |         "dialyzer"
 84 |       ],
 85 |     ]
 86 |   end
 87 | 
 88 |   defp mkdocs(_args) do
 89 |     docs = Path.join([File.cwd!, "bin", "docs"])
 90 |     {_, 0} = System.cmd(docs, ["build"], into: IO.stream(:stdio, :line))
 91 |   end
 92 | 
 93 |   defp docs do
 94 |     [
 95 |       source_url: "https://github.com/bitwalker/distillery",
 96 |       homepage_url: "https://github.com/bitwalker/distillery",
 97 |       main: "home"
 98 |     ]
 99 |   end
100 | 
101 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
102 |   defp elixirc_paths(_), do: ["lib"]
103 | end
104 | 


--------------------------------------------------------------------------------
/mkdocs.yml:
--------------------------------------------------------------------------------
 1 | site_name: Distillery Documentation
 2 | docs_dir: 'docs'
 3 | site_dir: 'doc'
 4 | theme: 'material'
 5 | use_directory_urls: false
 6 | markdown_extensions:
 7 |     - markdown.extensions.toc:
 8 |         permalink: true
 9 |     - markdown.extensions.admonition
10 |     - markdown.extensions.smarty
11 |     - markdown.extensions.wikilinks
12 |     - markdown.extensions.codehilite:
13 |         linenums: true
14 |     - pymdownx.caret
15 |     - pymdownx.details
16 |     - pymdownx.inlinehilite
17 |     - pymdownx.magiclink
18 |     - pymdownx.mark
19 |     - pymdownx.smartsymbols
20 |     - pymdownx.superfences
21 |     - pymdownx.tasklist:
22 |         custom_checkbox: true
23 |     - pymdownx.tilde
24 | extra:
25 |     palette:
26 |         primary: '#087da1'
27 |         accent: '#00a889'
28 |     font:
29 |         text: 'Source Sans Pro'
30 |     social:
31 |         - type: 'github'
32 |           link: 'https://github.com/bitwalker/distillery'
33 | repo_name: 'bitwalker/distillery'
34 | repo_url: 'https://github.com/bitwalker/distillery'
35 | copyright: 'Copyright 2018 Paul Schoenfelder'
36 | nav:
37 |     - Home: 'home.md'
38 |     - Installation: 'introduction/installation.md'
39 |     - 'Upgrading to 2.x': 'upgrading_to_2_0.md'
40 |     - 'Getting Started':
41 |         - 'Command Line Interface': 'tooling/cli.md'
42 |         - 'Understanding Releases': 'introduction/understanding_releases.md'
43 |         - 'Compare To Other Tools': 'introduction/comparison.md'
44 |         - 'Walkthrough': 'introduction/walkthrough.md'
45 |         - 'Umbrella Projects': 'introduction/umbrella_projects.md'
46 |         - 'Terminology': 'introduction/terminology.md'
47 |     - Guides:
48 |         - 'Phoenix': 'guides/phoenix_walkthrough.md'
49 |         - 'Building Releases In Docker': 'guides/building_in_docker.md'
50 |         - 'Deploying To Digital Ocean': 'guides/deploying_to_digital_ocean.md'
51 |         - 'Deploying To GCP': 'guides/deploying_to_google_cloud_platform.md'
52 |         - 'Deploying To AWS': 'guides/deploying_to_aws.md'
53 |         - 'Deploying With Docker': 'guides/working_with_docker.md'
54 |         - 'Upgrades and Downgrades': 'guides/upgrades_and_downgrades.md'
55 |         - 'Appups': 'guides/appups.md'
56 |         - 'Migrations': 'guides/running_migrations.md'
57 |         - 'systemd': 'guides/systemd.md'
58 |     - Configuration:
59 |         - 'Configuring Distillery': 'config/distillery.md'
60 |         - 'Runtime Configuration': 'config/runtime.md'
61 |         - 'VM Args': 'config/vm.args.md'
62 |         - 'PID Files': 'config/pidfiles.md'
63 |     - Extensibility:
64 |         - 'Release Plugins': 'extensibility/release_plugins.md'
65 |         - 'Config Providers': 'extensibility/config_providers.md'
66 |         - 'Custom Commands': 'extensibility/custom_commands.md'
67 |         - 'Overlays': 'extensibility/overlays.md'
68 |         - 'Boot Hooks': 'extensibility/boot_hooks.md'
69 |         - 'Shell Scripts': 'extensibility/shell_scripts.md'
70 |         - 'Appup Transforms': 'extensibility/appup_transforms.md'
71 |     - 'Module Documentation': 'api-reference.html'
72 |     - Changelog: 'changelog.md'
73 |     - FAQ: 'faq.md'
74 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/attach.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | # Attaches to the release console as started via `start`
 4 | # NOTE: This is not a remote console, it's the shell of the running node,
 5 | # so killing the shell will kill the node as well.
 6 | 
 7 | set -e
 8 | 
 9 | PIPE_DIR="${PIPE_DIR:-$RELEASE_MUTABLE_DIR/erl_pipes/$NAME/}"
10 | 
11 | exec "$BINDIR/to_erl" "$PIPE_DIR"
12 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/command.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -o posix
 4 | 
 5 | # DEPRECATED: Use `eval` instead
 6 | # Execute as command-line utility
 7 | #
 8 | # Like the escript command, this does not start the OTP application.
 9 | # If your command depends on a running OTP application,
10 | # use the following in your Elixir code.
11 | #
12 | #     {:ok, _} = Application.ensure_all_started(:your_app)
13 | 
14 | set -e
15 | 
16 | require_cookie
17 | 
18 | MODULE="$1"; shift
19 | FUNCTION="$1"; shift
20 | 
21 | # Save extra arguments
22 | ARGS=$*
23 | 
24 | # Checks is a module/function pair is defined
25 | is_function_defined() {
26 |     if [ -z "$1" ]; then
27 |         fail "No module name was provided to is_function_defined, please report this issue on the tracker!"
28 |     fi
29 |     if [ -z "$2" ]; then
30 |         fail "No function name was provided to is_function_defined, please report this issue on the tracker!"
31 |     fi
32 |     erl -eval "code:ensure_modules_loaded(['$1']), io:format(\"~p~n\", [erlang:function_exported('$1', $2, 0)]), halt()" \
33 |         -noshell \
34 |         -boot "$RELEASE_ROOT_DIR/bin/start_clean"
35 | }
36 | 
37 | # Build arguments for erlexec
38 | set -- "$@" -noshell
39 | set -- "$@" -boot "$RELEASE_ROOT_DIR/bin/start_clean"
40 | set -- "$@" -s "$MODULE" "$FUNCTION"
41 | set -- "$@" -s erlang halt
42 | 
43 | __is_defined=$(is_function_defined "$MODULE" "$FUNCTION")
44 | if [ "$__is_defined" = "false" ]; then
45 |     fail "$MODULE.$FUNCTION is either not defined or has a non-zero arity"
46 | fi
47 | 
48 | erlexec "$@" $ERL_OPTS -extra $ARGS
49 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/console.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## This command starts the release interactively, i.e. it boots to a shell
 4 | 
 5 | set -e
 6 | 
 7 | require_cookie
 8 | 
 9 | # .boot file typically just $REL_NAME (ie, the app name)
10 | # however, for debugging, sometimes start_clean.boot is useful.
11 | # For e.g. 'setup', one may even want to name another boot script.
12 | command="$1"
13 | case "$1" in
14 |     console)
15 |         shift
16 |         if [ -f "$REL_DIR/$REL_NAME.boot" ]; then
17 |             BOOTFILE="$REL_DIR/$REL_NAME"
18 |         else
19 |             BOOTFILE="$REL_DIR/start"
20 |         fi
21 |         ;;
22 |     console_clean)
23 |         shift
24 |         BOOTFILE="$RELEASE_ROOT_DIR/bin/start_clean"
25 |         ;;
26 |     console_boot)
27 |         shift
28 |         BOOTFILE="$1"
29 |         shift
30 |         ;;
31 | esac
32 | 
33 | # Setup beam-required vars
34 | PROGNAME="${0#*/}"
35 | export PROGNAME
36 | 
37 | # Start the VM, executing pre_start hook along
38 | # the way. We can't run the post_start hook because
39 | # the console will crash with no TTY attached
40 | run_hooks pre_start
41 | 
42 | # Dump environment info for logging purposes
43 | if [ ! -z "$VERBOSE" ]; then
44 |     echo "Exec: $command" -- "$*" "${EXTRA_OPTS}"
45 |     echo "Root: $ROOTDIR"
46 |     echo "Boot: $BOOTFILE"
47 |     echo "Args: $VMARGS_PATH"
48 |     echo "Mode: $CODE_LOADING_MODE"
49 |     echo "Opts: ${ERL_OPTS}"
50 | 
51 |     # Log the startup
52 |     echo "$RELEASE_ROOT_DIR"
53 | fi
54 | 
55 | logger -t "$REL_NAME[$$]" "Starting up"
56 | 
57 | erlexec \
58 |     -boot "$BOOTFILE" \
59 |     -args_file "$VMARGS_PATH" \
60 |     -mode "$CODE_LOADING_MODE" \
61 |     ${ERL_OPTS} \
62 |     -user Elixir.IEx.CLI \
63 |     -extra --no-halt +iex \
64 |     -- "$@"
65 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/describe.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Print a summary of information about this release
 4 | 
 5 | set -e
 6 | 
 7 | _load_cookie
 8 | 
 9 | release_ctl describe \
10 |             --release-root-dir="$RELEASE_ROOT_DIR" \
11 |             --release="$REL_NAME" \
12 |             --name="$NAME" \
13 |             --cookie="$COOKIE" \
14 |             --sysconfig="$SYS_CONFIG_PATH" \
15 |             --vmargs="$VMARGS_PATH" \
16 |             --erl-opts="$ERL_OPTS" \
17 |             --run-erl-env="$RUN_ERL_ENV"
18 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/escript.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## This command is used to execute an escript using the release ERTS
 4 | 
 5 | set -e
 6 | 
 7 | if ! escript "$@"; then
 8 |     exit 1
 9 | fi
10 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/eval.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | ## Evaluate some Erlang code against the running node
4 | 
5 | set -e
6 | 
7 | release_ctl eval "$@"
8 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/foreground.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## This command starts the release in the foreground, i.e.
 4 | ## standard out is routed to the current terminal session.
 5 | 
 6 | set -e
 7 | set -m
 8 | 
 9 | require_cookie
10 | 
11 | [ -f "$REL_DIR/$REL_NAME.boot" ] && BOOTFILE="$REL_NAME" || BOOTFILE=start
12 | FOREGROUNDOPTIONS="-noshell -noinput +Bd"
13 | 
14 | # Setup beam-required vars
15 | PROGNAME="${0#*/}"
16 | export PROGNAME
17 | 
18 | # Store passed arguments since they will be erased by `set`
19 | ARGS="$*"
20 | 
21 | # Start the VM, executing pre and post start hooks
22 | run_hooks pre_start
23 | 
24 | # Build an array of arguments to pass to exec later on
25 | # Build it here because this command will be used for logging.
26 | set -- $FOREGROUNDOPTIONS \
27 |     -boot "$REL_DIR/$BOOTFILE" \
28 |     -args_file "$VMARGS_PATH" \
29 |     -mode "$CODE_LOADING_MODE" \
30 |     ${ERL_OPTS} \
31 |     -extra ${EXTRA_OPTS}
32 | 
33 | # Dump environment info for logging purposes
34 | if [ ! -z "$VERBOSE" ]; then
35 |     echo "Exec: $*" -- "${1+$ARGS}"
36 |     echo "Root: $ROOTDIR"
37 | fi
38 | 
39 | post_start_fg() {
40 |     sleep 2
41 |     run_hooks post_start
42 | }
43 | 
44 | (post_start_fg &)
45 | erlexec "$@" -- "${1+$ARGS}"
46 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/help.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | if [ ! -z "$1" ]; then
 6 |     # We should delegate this to the command tool
 7 |     release_ctl help "$@"
 8 |     exit 1
 9 | fi
10 | 
11 | echo "USAGE"
12 | echo "  $REL_NAME <task> [options] [args..]"
13 | echo
14 | echo "COMMANDS"
15 | echo
16 | echo "  start                Start $REL_NAME as a daemon"
17 | echo "  start_boot <file>    Start $REL_NAME as a daemon, but supply a custom .boot file"
18 | echo "  foreground           Start $REL_NAME in the foreground"
19 | echo "  console              Start $REL_NAME with a console attached"
20 | echo "  console_clean        Start a console with code paths set but no apps loaded/started"
21 | echo "  console_boot <file>  Start $REL_NAME with a console attached, but supply a custom .boot file"
22 | echo "  stop                 Stop the $REL_NAME daemon"
23 | echo "  restart              Restart the $REL_NAME daemon without shutting down the VM"
24 | echo "  reboot               Restart the $REL_NAME daemon"
25 | echo "  upgrade <version>    Upgrade $REL_NAME to <version>"
26 | echo "  downgrade <version>  Downgrade $REL_NAME to <version>"
27 | echo "  attach               Attach the current TTY to $REL_NAME's console"
28 | echo "  remote_console       Remote shell to $REL_NAME's console"
29 | echo "  reload_config        Reload the current system's configuration from disk"
30 | echo "  pid                  Get the pid of the running $REL_NAME instance"
31 | echo "  ping                 Checks if $REL_NAME is running, pong is returned if successful"
32 | echo "  pingpeer <peer>      Check if a peer node is running, pong is returned if successful"
33 | echo "  escript              Execute an escript"
34 | echo "  rpc                  Execute Elixir code on the running node"
35 | echo "  eval                 Execute Elixir code locally"
36 | echo "  describe             Print useful information about the $REL_NAME release"
37 | __has_commands=0
38 | for command in "$REL_DIR"/commands/*.sh; do
39 |     [ -f "$command" ] || continue
40 |     __has_commands=1
41 |     echo "  $(basename ${command%.*}) (custom command)"
42 | done
43 | if [ "$__has_commands" -eq 0 ]; then
44 |     echo 
45 |     echo "No custom commands found."
46 | fi
47 | echo
48 | echo "Use $REL_NAME help <task> to get more information about a particular task (except custom commands)"
49 | exit 1
50 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/info.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | set -e
4 | 
5 | release_remote_ctl info "$@"
6 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/install.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## This command is used to install upgrades/downgrades.
 4 | ## It takes two arguments, the type of install (i.e. upgrade/downgrade),
 5 | ## and the version to install.
 6 | 
 7 | set -e
 8 | 
 9 | if [ -z "$2" ]; then
10 |     fail "Missing package argument\\nUsage: $REL_NAME $1 <version>"
11 | fi
12 | 
13 | if [ ! -z "$RELEASE_READ_ONLY" ]; then
14 |     fail "Cannot install a release upgrade with RELEASE_READ_ONLY set!"
15 | fi
16 | 
17 | require_live_node
18 | 
19 | SOURCE_VERSION="$REL_VSN"
20 | TARGET_VERSION="$2"
21 | 
22 | release_remote_ctl unpack \
23 |          --release="$REL_NAME" \
24 |          "$TARGET_VERSION"
25 | 
26 | # Update environment to reflect target version environment
27 | export REL_VSN="$TARGET_VERSION"
28 | export REL_DIR="$RELEASE_ROOT_DIR/releases/$TARGET_VERSION"
29 | 
30 | # Prepare new configs
31 | if [ "$SRC_VMARGS_PATH" = "$RELEASE_MUTABLE_DIR/vm.args" ]; then
32 |     unset VMARGS_PATH
33 | else
34 |     if [ "$SRC_VMARGS_PATH" = "$RELEASE_ROOT_DIR/releases/$SOURCE_VERSION/vm.args" ]; then
35 |         unset VMARGS_PATH
36 |     else
37 |         export VMARGS_PATH="$SRC_VMARGS_PATH"
38 |     fi
39 | fi
40 | if [ "$SRC_SYS_CONFIG_PATH" = "$RELEASE_MUTABLE_DIR/sys.config" ]; then
41 |     unset SYS_CONFIG_PATH
42 | else
43 |     if [ "$SRC_SYS_CONFIG_PATH" = "$RELEASE_ROOT_DIR/releases/$SOURCE_VERSION/sys.config" ]; then
44 |         unset SYS_CONFIG_PATH
45 |     else
46 |         export SYS_CONFIG_PATH="$SRC_SYS_CONFIG_PATH"
47 |     fi
48 | fi
49 | configure_release
50 | # We have to do some juggling to ensure the correct config is used by the upgrade handler
51 | # First, we detect if there was a failed upgrade, so we can start over
52 | if [ -f "$REL_DIR/sys.config.bak" ]; then
53 |     mv "$REL_DIR/sys.config.bak" "$REL_DIR/sys.config"
54 | fi
55 | if [ -f "$REL_DIR/vm.args.bak" ]; then
56 |     mv "$REL_DIR/vm.args.bak" "$REL_DIR/vm.args"
57 | fi
58 | # Then, backup the packaged configs
59 | cp -a "$REL_DIR/sys.config" "$REL_DIR/sys.config.bak"
60 | cp -a "$REL_DIR/vm.args" "$REL_DIR/vm.args.bak"
61 | # Then, substitute in the prepared configs
62 | cp -a "$SYS_CONFIG_PATH" "$REL_DIR/sys.config"
63 | cp -a "$VMARGS_PATH" "$REL_DIR/vm.args"
64 | 
65 | # Run any pre-upgrade tasks
66 | run_hooks pre_upgrade
67 | 
68 | release_remote_ctl install \
69 |          --release="$REL_NAME" \
70 |          "$TARGET_VERSION"
71 | 
72 | # We were successful, clean up the configs
73 | mv "$REL_DIR/sys.config.bak" "$REL_DIR/sys.config"
74 | mv "$REL_DIR/vm.args.bak" "$REL_DIR/vm.args"
75 | 
76 | # Update environment
77 | reset_code_paths
78 | reset_hooks
79 | 
80 | # Run any post-upgrade hooks
81 | run_hooks post_upgrade
82 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/pid.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Print the running node's process id to stdout
 4 | 
 5 | set -e
 6 | 
 7 | if ! get_pid; then
 8 |     exit 1
 9 | fi
10 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/ping.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Pings the running node, or an arbitrary peer node
 4 | ## by supplying `--name` and `--cookie` flags.
 5 | ##
 6 | ## If the node is running and can be connected to,
 7 | ## 'pong' will be printed to stdout. If the node is
 8 | ## not reachable or cannot be connected to due to an
 9 | ## invalid cookie, 'pang' will be printed to stdout
10 | ## and the command will exit with a non-zero status code.
11 | 
12 | set -e
13 | 
14 | require_cookie
15 | 
16 | if ! release_ctl ping --name="$NAME" --cookie="$COOKIE" "$@"; then
17 |     exit 1
18 | fi
19 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/pingpeer.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## DEPRECATED: Just use `ping --name=<name>` or
 4 | ## `ping --name=<name> --cookie=<cookie>`
 5 | ##
 6 | ## This command is like `ping`, but pings an arbitrary peer
 7 | 
 8 | set -e
 9 | 
10 | require_cookie
11 | 
12 | case $1 in
13 |     --*)
14 |         # New format, --cookie will be overridden if passed
15 |         if ! release_ctl ping --cookie="$COOKIE" "$@"; then
16 |             exit 1
17 |         fi
18 |         ;;
19 |     *)
20 |         # Old format
21 |         if ! release_ctl ping --cookie="$COOKIE" --name="$1"; then
22 |             exit 1
23 |         fi
24 |         ;;
25 | esac
26 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/reboot.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Restart the VM completely
 4 | 
 5 | set -e
 6 | 
 7 | require_cookie
 8 | 
 9 | if ! release_remote_ctl reboot; then
10 |     exit 1
11 | fi
12 | 
13 | sleep 1
14 | 
15 | # Check to see if node is back, if not, restart it without heart
16 | # Node needs to be brought back up without heart
17 | if ! release_remote_ctl ping >/dev/null; then
18 |     . "$REL_DIR/libexec/commands/start.sh" start
19 | fi
20 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/reload_config.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Reloads the running system's configuration
 4 | 
 5 | set -e
 6 | 
 7 | if ! erl -noshell -boot "${REL_DIR}/config" -s erlang halt >/dev/null; then
 8 |     fail "Unable to configure release!"
 9 | fi
10 | release_remote_ctl reload_config --sysconfig="$SYS_CONFIG_PATH"
11 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/remote_console.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Connect a remote shell to a running node
 4 | 
 5 | set -e
 6 | 
 7 | require_cookie
 8 | require_live_node
 9 | 
10 | # Generate a unique id used to allow multiple remsh to the same node
11 | # transparently
12 | id="remsh$(gen_id)-${NAME}"
13 | 
14 | # Get the node's ticktime so that we use the same thing.
15 | TICKTIME="$(release_remote_ctl rpc ':net_kernel.get_net_ticktime()')"
16 | 
17 | # Setup remote shell command to control node
18 | if [ ! -z "$USE_ERL_SHELL" ]; then
19 |     erl -hidden \
20 |         -kernel logger_level warning \
21 |         -kernel net_ticktime "$TICKTIME" \
22 |         "$NAME_TYPE" "$id" \
23 |         -remsh "$NAME" \
24 |         -setcookie "$COOKIE"
25 | else
26 |     iex --erl "-hidden -kernel net_ticktime $TICKTIME" \
27 |         --logger-sasl-reports false \
28 |         -"$NAME_TYPE" "$id" \
29 |         --cookie "$COOKIE" \
30 |         --remsh "$NAME"
31 | fi
32 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/restart.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Restart the VM without exiting the process
 4 | 
 5 | set -e
 6 | 
 7 | if ! release_remote_ctl restart; then
 8 |     exit 1
 9 | fi
10 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/rpc.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | ## Execute an MFA on the running node via `:rpc`
4 | 
5 | set -e
6 | 
7 | release_remote_ctl rpc "$@"
8 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/start.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Start a daemon in the background with an attachable shell
 4 | 
 5 | set -e
 6 | 
 7 | if [ ! -z "$RELEASE_READ_ONLY" ]; then
 8 |     fail "Cannot start a release with RELEASE_READ_ONLY set!"
 9 | fi
10 | 
11 | require_cookie
12 | 
13 | # Output a start command for the last argument of run_erl
14 | _start_command() {
15 |     printf "exec \"%s\" \"%s\" -- %s %s" "$RELEASE_ROOT_DIR/bin/$REL_NAME" \
16 |            "$START_OPTION" "${ARGS}" "${EXTRA_OPTS}"
17 | }
18 | 
19 | CMD=$1
20 | case "$1" in
21 |     start)
22 |         shift
23 |         START_OPTION="console"
24 |         HEART_OPTION="start"
25 |         ;;
26 |     start_boot)
27 |         shift
28 |         START_OPTION="console_boot"
29 |         HEART_OPTION="start_boot"
30 |         ;;
31 | esac
32 | ARGS="$*"
33 | RUN_PARAM="$*"
34 | 
35 | run_hooks pre_start
36 | 
37 | # Set arguments for the heart command
38 | set -- "$SCRIPT_DIR/$REL_NAME" "$HEART_OPTION"
39 | [ "$RUN_PARAM" ] && set -- "$@" "$RUN_PARAM"
40 | 
41 | # Export the HEART_COMMAND
42 | HEART_COMMAND="$RELEASE_ROOT_DIR/bin/$REL_NAME $CMD"
43 | export HEART_COMMAND
44 | 
45 | PIPE_DIR="${PIPE_DIR:-$RELEASE_MUTABLE_DIR/erl_pipes/$NAME/}"
46 | mkdir -p "$PIPE_DIR"
47 | 
48 | env $RUN_ERL_ENV "$BINDIR/run_erl" -daemon "$PIPE_DIR" "$RUNNER_LOG_DIR" \
49 |     "$(_start_command)"
50 | 
51 | run_hooks post_start
52 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/stop.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## Stops a daemon started via `start`
 4 | 
 5 | set -e
 6 | 
 7 | require_live_node
 8 | run_hooks pre_stop
 9 | 
10 | # Wait for the node to completely stop...
11 | PID="$(get_pid)"
12 | if ! release_remote_ctl stop; then
13 |     exit 1
14 | fi
15 | 
16 | # Wait until the pid is gone
17 | while kill -s 0 "$PID" 2>/dev/null;
18 | do
19 |     sleep 1
20 | done
21 | 
22 | # Finally, run all post_stop hooks
23 | run_hooks post_stop
24 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/unpack.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | ## This command unpacks a specific version of a release.
 4 | ## This does NOT install the version.
 5 | 
 6 | set -e
 7 | 
 8 | if [ ! -z "$RELEASE_READ_ONLY" ]; then
 9 |     fail "Cannot unpack a release with RELEASE_READ_ONLY set!"
10 | fi
11 | 
12 | release_remote_ctl unpack \
13 |         --release="$REL_NAME" \
14 |         "$2"
15 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/console.ps1:
--------------------------------------------------------------------------------
 1 | ## Run the app in console mode
 2 | $bin = whereis-erts-bin
 3 | $werl = (join-path $bin werl)
 4 | 
 5 | $boot = (join-path $Env:REL_DIR $Env:REL_NAME)
 6 | 
 7 | $argv = @("-boot", $boot)
 8 | $argv += @("-config", $Env:SYS_CONFIG_PATH)
 9 | $argv += @("-args_file", $Env:VMARGS_PATH)
10 | $argv += @("-user", "Elixir.IEx.CLI")
11 | $argv += @("-extra", "--no-halt", "+iex")
12 | 
13 | run-hooks -Phase pre_start
14 | 
15 | $post_start = {
16 |     start-sleep -Second 2
17 |     run-hooks -Phase post_start
18 | }
19 | 
20 | # Run post-start hooks asynchronously
21 | start-job -Name "post_start hooks" -ScriptBlock $post_start
22 | 
23 | $base_args = erl-args @argv
24 | 
25 | & $werl @base_args @argv
26 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/describe.ps1:
--------------------------------------------------------------------------------
 1 | ## Print a summary of information about this release
 2 | 
 3 | load-cookie
 4 | 
 5 | $describe_args = @()
 6 | $describe_args += ('--release-root-dir="{0}"' -f $Env:RELEASE_ROOT_DIR)
 7 | $describe_args += ('--release="{0}"' -f $Env:REL_NAME)
 8 | $describe_args += ('--name="{0}"' -f $Env:NAME)
 9 | $describe_args += ('--cookie="{0}"' -f $Env:COOKIE)
10 | $describe_args += ('--sysconfig="{0}"' -f $Env:SYS_CONFIG_PATH)
11 | $describe_args += ('--vmargs="{0}"' -f $Env:VMARGS_PATH)
12 | $describe_args += ('--erl-opts="{0}"' -f $Env:ERL_OPTS)
13 | $describe_args += ('--run-erl-env="{0}"' -f $Env:RUN_ERL_ENV)
14 | 
15 | release-ctl describe @describe_args
16 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/escript.ps1:
--------------------------------------------------------------------------------
1 | ## This command is used to execute an escript using the release ERTS
2 | 
3 | escript @args
4 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/eval.ps1:
--------------------------------------------------------------------------------
1 | ## Evaluate some Erlang code against the running node
2 | 
3 | release-ctl eval @args
4 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/foreground.ps1:
--------------------------------------------------------------------------------
 1 | ## This command starts the release in the foreground, i.e.
 2 | ## standard out is routed to the current terminal session.
 3 | 
 4 | require-cookie
 5 | 
 6 | # Start the VM, executing pre and post start hooks
 7 | run-hooks -Phase pre_start
 8 | 
 9 | $boot = (join-path $Env:REL_DIR $Env:REL_NAME)
10 | 
11 | $post_start = {
12 |     start-sleep -Second 2
13 |     run-hooks -Phase post_start
14 | }
15 | 
16 | # Build argument vector for erl
17 | $erl_opts = @()
18 | if ($Env:ERL_OPTS -ne $null) {
19 |     $erl_opts = string-to-argv -String $Env:ERL_OPTS
20 | }
21 | $extra_opts = @()
22 | if ($Env:EXTRA_OPTS -ne $null) {
23 |     $extra_opts = string-to-argv -String $Env:EXTRA_OPTS
24 | }
25 | 
26 | $argv = @("-noshell", "-noinput", "+Bd")
27 | $argv += @("-boot", $boot)
28 | $argv += @("-args_file", "$Env:VMARGS_PATH")
29 | $argv += @("-mode", "embedded")
30 | $argv += $erl_opts
31 | $argv += "-extra"
32 | $argv += $extra_opts
33 | $argv += $args
34 | 
35 | # Run post-start hooks asynchronously
36 | start-job -Name "post_start hooks" -ScriptBlock $post_start
37 | 
38 | erl @argv
39 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/help.ps1:
--------------------------------------------------------------------------------
 1 | if ($args.Length -gt 0) {
 2 |     # We should delegate this to the command tool
 3 |     release-ctl help @args
 4 |     exit
 5 | }
 6 | 
 7 | write-host (@"
 8 | USAGE
 9 |   {0} <task> [options] [args..]
10 | 
11 | COMMANDS"
12 | 
13 |   start                Start {0} as a daemon
14 |   foreground           Start {0} in the foreground
15 |   console              Start {0} with a console attached
16 |   stop                 Stop the {0} daemon
17 |   restart              Restart the {0} daemon without shutting down the VM
18 |   reboot               Restart the {0} daemon
19 |   upgrade <version>    Upgrade {0} to <version>
20 |   downgrade <version>  Downgrade {0} to <version>
21 |   remote_console       Remote shell to $REL_NAME's console
22 |   reload_config        Reload the current system's configuration from disk
23 |   pid                  Get the pid of the running $REL_NAME instance
24 |   ping                 Checks if {0} is running, pong is returned if successful
25 |   escript              Execute an escript
26 |   rpc                  Execute Elixir code on the running node
27 |   eval                 Execute Elixir code locally
28 |   describe             Print useful information about the $REL_NAME release
29 | "@ -f $Env:REL_NAME)
30 | 
31 | $commands = get-childitem -Directory (join-path $Env:REL_DIR "commands") -Filter "*.ps1" | foreach { $_.Name -replace ".ps1","" }
32 | if ($commands.Length -gt 0) {
33 |     $commands | foreach { write-host ("  {0} (custom command)" -f $_) }
34 | } else {
35 |     write-host "No custom commands found."
36 | }
37 | write-host
38 | write-host ("Use '{0} help <task>' to get more information about a particular task (except custom commands)" -f $Env:REL_NAME)
39 | exit
40 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/info.ps1:
--------------------------------------------------------------------------------
1 | release-remote-ctl info @args
2 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/install.ps1:
--------------------------------------------------------------------------------
 1 | ## Install the release as a Windows service via erlsrv
 2 | 
 3 | #Requires -RunAsAdministrator
 4 | 
 5 | require-cookie
 6 | 
 7 | # With releases, service name must be '<nodename>_<release vsn>' per the docs
 8 | $nodename = $Env:NAME -replace "@.+$",""
 9 | $service_name = ("{0}_{1}" -f $nodename,$Env:REL_VSN)
10 | 
11 | $desc = "{0} version {1} running in {2}" -f $Env:REL_NAME,$Env:REL_VSN,$Env:RELEASE_ROOT_DIR
12 | 
13 | $bin = whereis-erts-bin
14 | $erlsrv = (join-path $bin "erlsrv.exe")
15 | $start_erl = (join-path $bin "start_erl.exe")
16 | 
17 | $erl_opts = string-to-argv -String $Env:ERL_OPTS
18 | 
19 | $service_argv = @()
20 | $service_argv += $erl_opts
21 | $service_argv += @("-boot_var", "ERTS_LIB_DIR", $Env:ERTS_LIB_DIR)
22 | $service_argv += @("-config", $Env:SYS_CONFIG_PATH)
23 | $service_argv += @("-setcookie", $Env:COOKIE)
24 | # Add code paths
25 | $codepaths = get-code-paths
26 | $service_argv += "-pa"
27 | $service_argv += $codepaths
28 | $service_argv += @("-pa", $Env:CONSOLIDATED_DIR)
29 | $base_argv = erl-args @service_argv
30 | # Add start_erl opts, delimited by ++
31 | $service_argv += "++"
32 | $service_argv += "-noconfig"
33 | $service_argv += @("-rootdir", $Env:RELEASE_ROOT_DIR)
34 | $service_argv += @("-reldir", (join-path $Env:RELEASE_ROOT_DIR "releases"))
35 | $service_argv += @("-data", "$Env:START_ERL_DATA)
36 | 
37 | $service_argv = $service_argv | foreach { 
38 |     if ($_.StartsWith("-") -or $_.StartsWith("+")) {
39 |         # Don't quote flags
40 |         $_
41 |     } else {
42 |         ensure-quoted $_
43 |     }
44 | }
45 | 
46 | # Convert argv into a string for -args
47 | $base_args = $base_argv -join " "
48 | $service_args = $service_argv -join " "
49 | $service_args = $base_args, $service_args -join " "
50 | 
51 | $name_type = ("-{0}" -f $Env:NAME_TYPE)
52 | 
53 | $argv = @("add", $service_name)
54 | $argv += @("-comment", (ensure-quoted $desc))
55 | $argv += @($name_type, $Env:NAME)
56 | $argv += @("-workdir", $Env:RELEASE_ROOT_DIR)
57 | $argv += @("-machine", $start_erl)
58 | $argv += @("-stopaction", (ensure-quoted "init:stop()."))
59 | $argv += @("-args", (ensure-quoted $service_args))
60 | 
61 | & $erlsrv @argv
62 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/ping.ps1:
--------------------------------------------------------------------------------
 1 | ## Pings the running node, or an arbitrary peer node
 2 | ## by supplying `--name` and `--cookie` flags.
 3 | ##
 4 | ## If the node is running and can be connected to,
 5 | ## 'pong' will be printed to stdout. If the node is
 6 | ## not reachable or cannot be connected to due to an
 7 | ## invalid cookie, 'pang' will be printed to stdout
 8 | ## and the command will exit with a non-zero status code.
 9 | 
10 | require-cookie
11 | 
12 | $argv = @()
13 | $argv += "--name=$Env:NAME"
14 | $argv += "--cookie=$Env:COOKIE"
15 | $argv += $args
16 | 
17 | release-ctl ping $argv
18 | if ($LastExitCode -ne 0) {
19 |     exit 1
20 | }
21 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/reboot.ps1:
--------------------------------------------------------------------------------
 1 | ## Restart the VM completely
 2 | 
 3 | require-live-node
 4 | 
 5 | $service_name = ("{0}_{1}" -f $Env:REL_NAME,$Env:REL_VSN)
 6 | 
 7 | $bin = whereis-erts-bin
 8 | $erlsrv = (join-path $bin "erlsrv.exe")
 9 | 
10 | # Stop first
11 | run-hooks -Phase pre_stop
12 | & $erlsrv stop $service_name
13 | if ($LastExitCode -ne 0) {
14 |     exit 1
15 | }
16 | run-hooks -Phase post_stop
17 | 
18 | # Restart
19 | run-hooks -Phase pre_start
20 | & $erlsrv start $service_name
21 | if ($LastExitCode -ne 0) {
22 |     exit 1
23 | }
24 | run-hooks -Phase post_start
25 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/remote_console.ps1:
--------------------------------------------------------------------------------
 1 | ## Attach a remote console
 2 | 
 3 | require-live-node
 4 | 
 5 | $id = gen-nodename
 6 | 
 7 | $bin = whereis-erts-bin
 8 | $werl = (join-path $bin werl)
 9 | 
10 | $start_clean = "start_clean"
11 | if ($bin.StartsWith($Env:RELEASE_ROOT_DIR)) {
12 |     $start_clean = (join-path $Env:RELEASE_ROOT_DIR (join-path "bin" "start_clean"))
13 | }
14 | 
15 | $argv = @("-hidden", "-noshell")
16 | $argv += @("-boot", $start_clean)
17 | $argv += @("-user", "Elixir.IEx.CLI")
18 | $argv += @("-$Env:NAME_TYPE", $id)
19 | $argv += @("-setcookie", $Env:COOKIE)
20 | $argv += @("-extra", "--no-halt", "+iex")
21 | $argv += @("--$Env:NAME_TYPE", $id)
22 | $argv += @("--cookie", $Env:COOKIE)
23 | $argv += @("--remsh", $Env:NAME)
24 | 
25 | & $werl @argv
26 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/restart.ps1:
--------------------------------------------------------------------------------
1 | ## Restart the VM without exiting the process
2 | 
3 | release-remote-ctl restart
4 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/rpc.ps1:
--------------------------------------------------------------------------------
1 | ## Execute an MFA on the running node via `:rpc`
2 | 
3 | release-remote-ctl rpc @args
4 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/start.ps1:
--------------------------------------------------------------------------------
 1 | ## Starts the Windows service created by 'install'
 2 | 
 3 | # With releases, service name must be '<nodename>_<release vsn>' per the docs
 4 | $nodename = $Env:NAME -replace "@.+$",""
 5 | $service_name = ("{0}_{1}" -f $nodename,$Env:REL_VSN)
 6 | 
 7 | $bin = whereis-erts-bin
 8 | $erlsrv = (join-path $bin "erlsrv.exe")
 9 | 
10 | run-hooks -Phase pre_start
11 | 
12 | & $erlsrv start $service_name
13 | 
14 | if ($LastExitCode -ne 0) {
15 |     exit 1
16 | }
17 | 
18 | run-hooks -Phase post_start
19 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/stop.ps1:
--------------------------------------------------------------------------------
 1 | ## Stops a daemon started via `start`
 2 | 
 3 | require-live-node
 4 | 
 5 | run-hooks -Phase pre_stop
 6 | 
 7 | # With releases, service name must be '<nodename>_<release vsn>' per the docs
 8 | $nodename = $Env:NAME -replace "@.+$",""
 9 | $service_name = ("{0}_{1}" -f $nodename,$Env:REL_VSN)
10 | 
11 | $bin = whereis-erts-bin
12 | $erlsrv = (join-path $bin "erlsrv.exe")
13 | 
14 | & $erlsrv stop $service_name
15 | 
16 | if ($LastExitCode -ne 0) {
17 |     exit 1
18 | }
19 | 
20 | run-hooks -Phase post_stop
21 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/uninstall.ps1:
--------------------------------------------------------------------------------
 1 | ## Uninstalls the Windows service created by 'install'
 2 | 
 3 | #Requires -RunAsAdministrator
 4 | 
 5 | $bin = whereis-erts-bin
 6 | $erlsrv = (join-path $bin "erlsrv.exe")
 7 | $epmd = (join-path $bin "epmd.exe")
 8 | 
 9 | # With releases, service name must be '<nodename>_<release vsn>' per the docs
10 | $nodename = $Env:NAME -replace "@.+$",""
11 | $service_name = ("{0}_{1}" -f $nodename,$Env:REL_VSN)
12 | 
13 | & $erlsrv remove $service_name
14 | if ($LastExitCode -ne 0) {
15 |     exit 1
16 | }
17 | 
18 | & $epmd -kill
19 | 


--------------------------------------------------------------------------------
/priv/libexec/commands/win/upgrade.ps1:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/priv/libexec/commands/win/upgrade.ps1


--------------------------------------------------------------------------------
/priv/libexec/env.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | # Disable flow control for run_erl
 6 | # Flow control can cause several problems. On Linux, if you
 7 | # accidentally hit Ctrl-S (instead of Ctrl-D to detach) and
 8 | # then some other key, the entire beam process will hang when
 9 | # attempting to write to stdout. On Solaris, the beam process
10 | # will hang on writing if ScrollLock is on.
11 | RUN_ERL_DISABLE_FLOWCNTRL="${RUN_ERL_DISABLE_FLOWCNTRL:-true}"
12 | # VM code loading mode, embedded by default, can also be interactive
13 | # See http://erlang.org/doc/man/code.html
14 | CODE_LOADING_MODE="${CODE_LOADING_MODE:-embedded}"
15 | # The lib directory for this release
16 | REL_LIB_DIR="${REL_LIB_DIR:-$RELEASE_ROOT_DIR/lib}"
17 | # The location of generated files and other mutable state
18 | RELEASE_MUTABLE_DIR="${RELEASE_MUTABLE_DIR:-$RELEASE_ROOT_DIR/var}"
19 | # When stdout is piped to a file, this is the directory those files will
20 | # be stored in. defaults to /log in the release root directory
21 | RUNNER_LOG_DIR="${RUNNER_LOG_DIR:-$RELEASE_MUTABLE_DIR/log}"
22 | # A string of extra options to pass to erl, here for plugins
23 | EXTRA_OPTS="${EXTRA_OPTS:-}"
24 | # The hook paths for each of the available hookable events
25 | reset_hooks() {
26 |     export PRE_CONFIGURE_HOOKS="$REL_DIR/hooks/pre_configure.d"
27 |     export POST_CONFIGURE_HOOKS="$REL_DIR/hooks/post_configure.d"
28 |     export PRE_START_HOOKS="$REL_DIR/hooks/pre_start.d"
29 |     export POST_START_HOOKS="$REL_DIR/hooks/post_start.d"
30 |     export PRE_STOP_HOOKS="$REL_DIR/hooks/pre_stop.d"
31 |     export POST_STOP_HOOKS="$REL_DIR/hooks/post_stop.d"
32 |     export PRE_UPGRADE_HOOKS="$REL_DIR/hooks/pre_upgrade.d"
33 |     export POST_UPGRADE_HOOKS="$REL_DIR/hooks/post_upgrade.d"
34 | }
35 | reset_hooks
36 | 
37 | # Exported environment variables
38 | export BINDIR="$ERTS_DIR/bin"
39 | export LD_LIBRARY_PATH="$ERTS_DIR/lib:$LD_LIBRARY_PATH"
40 | export EMU="beam"
41 | export PROGNAME="erl"
42 | 
43 | # Allow override of where to read configuration from
44 | # By default it's RELEASE_ROOT_DIR
45 | export RELEASE_CONFIG_DIR="${RELEASE_CONFIG_DIR:-$RELEASE_ROOT_DIR}"
46 | 
47 | # Make sure important directories exist
48 | if [ -z "$RELEASE_READ_ONLY" ] && [ ! -d "$RELEASE_MUTABLE_DIR" ]; then
49 |     mkdir -p "$RELEASE_MUTABLE_DIR"
50 |     echo "Files in this directory are regenerated frequently, edits will be lost" \
51 |         > "$RELEASE_MUTABLE_DIR/WARNING_README"
52 | fi
53 | 
54 | if [ -z "$RELEASE_READ_ONLY" ] && [ ! -d "$RUNNER_LOG_DIR" ]; then
55 |     mkdir -p "$RUNNER_LOG_DIR"
56 | fi
57 | 


--------------------------------------------------------------------------------
/priv/libexec/helpers.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | set -e
  4 | 
  5 | # Ensures the current node is running, otherwise fails
  6 | require_live_node() {
  7 |     require_cookie
  8 |     if ! release_ctl ping --name="$NAME" --cookie="$COOKIE" >/dev/null; then
  9 |         fail "Node $NAME is not running!"
 10 |     else
 11 |         return 0
 12 |     fi
 13 | }
 14 | 
 15 | # Get node pid
 16 | get_pid() {
 17 |     if output="$(release_remote_ctl rpc 'List.to_string(:os.getpid())')"
 18 |     then
 19 |         echo "$output" | sed -e 's/"//g'
 20 |         return 0
 21 |     else
 22 |         echo "$output"
 23 |         return 1
 24 |     fi
 25 | }
 26 | 
 27 | # Generate a unique nodename
 28 | gen_nodename() {
 29 |     id="$(gen_id)"
 30 |     node="$(echo "${NAME}" | cut -d'@' -f1)"
 31 |     host="$(echo "${NAME}" | cut -d'@' -f2 -s)"
 32 |     if [ -z "$host" ] && [ "$NAME_TYPE" = "-name" ]; then
 33 |         # No hostname specified, and we're using long names, so use HOSTNAME
 34 |         echo "${node}-${id}@${HOSTNAME}"
 35 |     elif [ -z "$host" ]; then
 36 |         # No hostname specified, but we're using -sname
 37 |         echo "${node}-${id}"
 38 |     elif [ "$NAME_TYPE" = "-sname" ]; then
 39 |         # Hostname specified, but we're using -sname
 40 |         echo "${node}-${id}"
 41 |     else
 42 |         # Hostname specified, and we're using long names
 43 |         echo "${node}-${id}@${host}"
 44 |     fi
 45 | }
 46 | 
 47 | # Print the current hostname
 48 | get_hostname() {
 49 |     host="$(echo "${NAME}" | cut -d'@' -f2 -s)"
 50 |     if [ -z "$host" ]; then
 51 |         echo "${HOSTNAME}"
 52 |     else
 53 |         echo "$host"
 54 |     fi
 55 | }
 56 | 
 57 | # Generate a random id
 58 | gen_id() {
 59 |     od -t x -N 4 /dev/urandom | head -n1 | awk '{print $2}'
 60 | }
 61 | 
 62 | ## Run hooks for one of the configured startup phases
 63 | run_hooks() {
 64 |     case $1 in
 65 |         pre_configure)
 66 |             _run_hooks_from_dir "$PRE_CONFIGURE_HOOKS"
 67 |             ;;
 68 |         post_configure)
 69 |             _run_hooks_from_dir "$POST_CONFIGURE_HOOKS"
 70 |             ;;
 71 |         pre_start)
 72 |             _run_hooks_from_dir "$PRE_START_HOOKS"
 73 |             ;;
 74 |         pre_stop)
 75 |             _run_hooks_from_dir "$PRE_STOP_HOOKS"
 76 |             ;;
 77 |         post_start)
 78 |             _run_hooks_from_dir "$POST_START_HOOKS"
 79 |             ;;
 80 |         post_stop)
 81 |             _run_hooks_from_dir "$POST_STOP_HOOKS"
 82 |             ;;
 83 |         pre_upgrade)
 84 |             _run_hooks_from_dir "$PRE_UPGRADE_HOOKS"
 85 |             ;;
 86 |         post_upgrade)
 87 |             _run_hooks_from_dir "$POST_UPGRADE_HOOKS"
 88 |             ;;
 89 |     esac
 90 | }
 91 | 
 92 | # Private. Run hooks from directory.
 93 | _run_hooks_from_dir() {
 94 |     if [ -d "$1" ]; then
 95 |         for file in $1/[0-9a-zA-Z._-]*; do
 96 |             [ -f "$file" ] || continue
 97 |             . "$file"
 98 |         done
 99 |     fi
100 | }
101 | 


--------------------------------------------------------------------------------
/priv/libexec/logger.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | if [ ! -z "$DEBUG_BOOT" ]; then
 5 |     # Disable debug mode in this file
 6 |     set +x
 7 | fi
 8 | 
 9 | IS_TTY=false
10 | if [ -t 1 ]; then
11 |     if command -v tput >/dev/null; then
12 |         IS_TTY=true
13 |     fi
14 | fi
15 | 
16 | if [ "$IS_TTY" = "true" ]; then
17 |     txtrst=$(tput sgr0 || echo "\e[0m")              # Reset
18 |     txtbld=$(tput bold || echo "\e[1m")              # Bold
19 |     bldred=${txtbld}$(tput setaf 1 || echo "\e[31m") # Red
20 |     bldgrn=${txtbld}$(tput setaf 2 || echo "\e[32m") # Green
21 |     bldylw=${txtbld}$(tput setaf 3 || echo "\e[33m") # Yellow
22 | else
23 |     txtrst=
24 |     txtbld=
25 |     bldred=
26 |     bldgrn=
27 |     bldylw=
28 | fi
29 | 
30 | # Log an error message in red and exit with a non-zero status
31 | fail() {
32 |     printf "${bldred}%s${txtrst}\n" "${*}"
33 |     exit 1
34 | }
35 | 
36 | # Log an informational message in yellow
37 | notice() {
38 |     printf "${bldylw}%s${txtrst}\n" "${*}"
39 | }
40 | 
41 | # Log a success message in green
42 | success() {
43 |     printf "${bldgrn}%s${txtrst}\n" "${*}"
44 | }
45 | 
46 | # Log an informational message
47 | info() {
48 |     printf "%s\n" "${*}"
49 | }
50 | 
51 | if [ ! -z "$DEBUG_BOOT" ]; then
52 |     # Re-enable it after
53 |     set -x
54 | fi
55 | 


--------------------------------------------------------------------------------
/priv/libexec/readlink.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | if [ ! -z "$DEBUG_BOOT" ]; then
 6 |     # Disable debug mode in this file
 7 |     set +x
 8 | fi
 9 | 
10 | # If readlink has no -f option, or greadlink is not available,
11 | # This function behaves like `readlink -f`
12 | __readlink_f() {
13 |     __target_file="$1"
14 |     cd "$(dirname "$__target_file")"
15 |     __target_file=$(basename "$__target_file")
16 | 
17 |     # Iterate down a (possible) chain of symlinks
18 |     while [ -L "$__target_file" ]
19 |     do
20 |         __target_file=$(readlink "$__target_file")
21 |         cd "$(dirname "$__target_file")"
22 |         __target_file=$(basename "$__target_file")
23 |     done
24 |     # Compute the canonicalized name by finding the physical path
25 |     # for the directory we're in and appending the target file.
26 |     __phys_dir=$(pwd -P)
27 |     __result="$__phys_dir/$__target_file"
28 |     echo "$__result"
29 | }
30 | 
31 | readlink_f() {
32 |     # Locate the real path to this script
33 |     if uname | grep -q 'Darwin'; then
34 |         # on OSX, best to install coreutils from homebrew or similar
35 |         # to get greadlink
36 |         if command -v greadlink >/dev/null 2>&1; then
37 |             greadlink -f "$1"
38 |         else
39 |             __readlink_f "$1"
40 |         fi
41 |     else
42 |         readlink -f "$1"
43 |     fi
44 | }
45 | 
46 | if [ ! -z "$DEBUG_BOOT" ]; then
47 |     # Re-enable it after
48 |     set -x
49 | fi
50 | 


--------------------------------------------------------------------------------
/priv/libexec/win/helpers.ps1:
--------------------------------------------------------------------------------
 1 | # Ensures the current node is running, otherwise fails
 2 | function Require-Live-Node {
 3 |     if (-not (ping)) {
 4 |         log-error ("Node {0} is not running!" -f $Env:NAME)
 5 |     }
 6 | }
 7 | 
 8 | function Ping {
 9 |     require-cookie
10 |     $argv = @()
11 |     $argv += "--name=$Env:NAME"
12 |     $argv += "--cookie=$Env:COOKIE"
13 |     $argv += $args
14 |     release-ctl ping @argv | out-null
15 |     if ($LastExitCode -ne 0) {
16 |         return $false
17 |     }
18 |     return $true
19 | }
20 | 
21 | # Get node pid
22 | function Get-Pid {
23 |     $output = release-remote-ctl rpc ":os.getpid()"
24 |     if ($LastExitCode -ne 0) {
25 |         $output
26 |     } else {
27 |         $output -replace "`"",""
28 |     }
29 | }
30 | 
31 | # Generate a unique nodename
32 | function Gen-NodeName {
33 |     $id = gen-id
34 |     $node, $rest = $Env:NAME.split("@")
35 |     $nodehost = (-join $rest)
36 |     if (($nodehost -eq "") -and ($Env:NAME_TYPE -eq "-name")) {
37 |         # No hostname specified, and we're using long names, so use HOSTNAME
38 |         "{0}-{1}@{2}" -f $node,$id,$Env:COMPUTERNAME
39 |     } elseif ($nodehost -eq "") {
40 |         # No hostname specified, but we're using -sname
41 |         "{0}-{1}" -f $node,$id
42 |     } elseif ($Env:NAME_TYPE -eq "-sname") {
43 |         # Hostname specified, but we're using -sname
44 |         "{0}-{1}" -f $node,$id
45 |     } else {
46 |         # Hostname specified, and we're using long names
47 |         "{0}-{1}@{2}" -f $node,$id,$nodehost
48 |     }
49 |     return
50 | }
51 | 
52 | # Print the current hostname
53 | function Get-HostName {
54 |     $null, $rest = $Env:NAME.split("@")
55 |     $nodehost = (-join $rest)
56 |     if ($nodehost -eq "") {
57 |         $Env:COMPUTERNAME
58 |     } else {
59 |         $nodehost
60 |     }
61 |     return
62 | }
63 | 
64 | # Generate a random id
65 | function Gen-Id {
66 |     get-random
67 | }
68 | 
69 | ## Run hooks for one of the configured startup phases
70 | function Run-Hooks {
71 |     param ($Phase = $(throw "You must set Phase when calling Run-Hooks!"))
72 |     $phase_dir = (join-path $Env:HOOKS_DIR ("{0}.d" -f $Phase))
73 |     if (test-path $phase_dir -PathType Container) {
74 |         run-hooks-from-dir $phase_dir
75 |     }
76 | }
77 | 
78 | # Private. Run hooks from directory.
79 | function Run-Hooks-From-Dir {
80 |     param ($Dir = $(throw "You must set Dir when calling Run-Hooks-From-Dir"))
81 |     get-childitem -Directory $Dir -Filter "*.ps1" | foreach { . $_.FullName }
82 | }
83 | 


--------------------------------------------------------------------------------
/priv/libexec/win/logger.ps1:
--------------------------------------------------------------------------------
 1 | function Log-Error {
 2 |     param ($Message = $(throw "Message parameter for Log-Error is required"))
 3 |     write-host "Error occurred! $Message" -ForegroundColor Red
 4 |     exit
 5 | }
 6 | 
 7 | function Log-Warning {
 8 |     param ($Message = $(throw "Message parameter for Log-Warning is required"))
 9 |     write-host $Message -ForegroundColor Yellow
10 | }
11 | 


--------------------------------------------------------------------------------
/priv/templates/erl_script.eex:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | set -e
 3 | 
 4 | SCRIPT_DIR=`dirname "$0"`
 5 | ROOTDIR=`cd "$SCRIPT_DIR"/../../ && pwd`
 6 | BINDIR=$ROOTDIR/erts-<%= erts_vsn %>/bin
 7 | EMU=beam
 8 | PROGNAME=`echo $0 | sed 's/.*\\///'`
 9 | export EMU
10 | export ROOTDIR
11 | export BINDIR
12 | export PROGNAME
13 | exec "$BINDIR/erlexec" ${1+"$@"}
14 | 


--------------------------------------------------------------------------------
/priv/templates/example_config.eex:
--------------------------------------------------------------------------------
 1 | # Import all plugins from `rel/plugins`
 2 | # They can then be used by adding `plugin MyPlugin` to
 3 | # either an environment, or release definition, where
 4 | # `MyPlugin` is the name of the plugin module.
 5 | ~w(rel plugins *.exs)
 6 | |> Path.join()
 7 | |> Path.wildcard()
 8 | |> Enum.map(&Code.eval_file(&1))
 9 | 
10 | use Distillery.Releases.Config,
11 |     # This sets the default release built by `mix distillery.release`
12 |     default_release: :default,
13 |     # This sets the default environment used by `mix distillery.release`
14 |     default_environment: Mix.env()
15 | <%= unless no_docs do %>
16 | # For a full list of config options for both releases
17 | # and environments, visit https://hexdocs.pm/distillery/config/distillery.html
18 | <% end %>
19 | <%= unless no_docs do %>
20 | # You may define one or more environments in this file,
21 | # an environment's settings will override those of a release
22 | # when building in that environment, this combination of release
23 | # and environment configuration is called a profile
24 | <% end %>
25 | environment :dev do
26 |   # If you are running Phoenix, you should make sure that
27 |   # server: true is set and the code reloader is disabled,
28 |   # even in dev mode.
29 |   # It is recommended that you build with MIX_ENV=prod and pass
30 |   # the --env flag to Distillery explicitly if you want to use
31 |   # dev mode.
32 |   set dev_mode: true
33 |   set include_erts: false
34 |   set cookie: <%= inspect(get_cookie.()) %>
35 | end
36 | 
37 | environment :prod do
38 |   set include_erts: true
39 |   set include_src: false
40 |   set cookie: <%= inspect(get_cookie.()) %>
41 |   set vm_args: "rel/vm.args"
42 | end
43 | <%= unless no_docs do %>
44 | # You may define one or more releases in this file.
45 | # If you have not set a default release, or selected one
46 | # when running `mix distillery.release`, the first release in the file
47 | # will be used by default<% end %>
48 | <%= for release <- releases do %><%= if Keyword.get(release, :is_umbrella) do %>
49 | release :<%= Keyword.get(release, :release_name) %> do
50 |   set version: "0.1.0"
51 |   set applications: [
52 |     :runtime_tools,
53 | <%= Enum.map(Keyword.get(release, :release_applications), fn {app, start_type} ->
54 |     "    #{app}: :#{start_type}"
55 |     end) |> Enum.join(",\n") %>
56 |   ]
57 | end<% else %>
58 | release :<%= Keyword.get(release, :release_name) %> do
59 |   set version: current_version(:<%= Keyword.get(release, :release_name)%>)
60 |   set applications: [
61 |     :runtime_tools
62 |   ]
63 | end<% end %>
64 | <% end %>
65 | 


--------------------------------------------------------------------------------
/priv/templates/executable_header.eex:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | unset CDPATH
 3 | 
 4 | # The name of the release being extracted
 5 | __EXEC_REL_NAME="<%= release_name %>"
 6 | # Determines if this script should clean up after execution
 7 | __EXEC_CLEANUP_AFTER="<%= executable_options[:transient] %>"
 8 | # The directory to which the release contents will be extracted
 9 | if [ -z "$RELEASE_MUTABLE_DIR" ]; then
10 |     __EXEC_TARGET_DIR="./tmp"
11 | else
12 |     __EXEC_TARGET_DIR="$RELEASE_MUTABLE_DIR/tmp"
13 | fi
14 | 
15 | mkdir -p "$__EXEC_TARGET_DIR"
16 | 
17 | # Only extract the release if it hasn't yet been extracted
18 | if [ ! -d "$__EXEC_TARGET_DIR/$__EXEC_REL_NAME" ]; then
19 |     mkdir -p "$__EXEC_TARGET_DIR/$__EXEC_REL_NAME"
20 |     DATA_BEGIN=`awk '/^__DATA_BEGIN__/ {print NR + 1; exit 0; }' $0`
21 |     tail -n+$DATA_BEGIN $0 | tar -xzf - -C "$__EXEC_TARGET_DIR/$__EXEC_REL_NAME"
22 | fi
23 | 
24 | # Pass arguments to bin/app script
25 | if [ "$__EXEC_CLEANUP_AFTER" != "true" ]; then
26 |     exec "$__EXEC_TARGET_DIR/$__EXEC_REL_NAME/bin/$__EXEC_REL_NAME" $@
27 | else
28 |     "$__EXEC_TARGET_DIR/$__EXEC_REL_NAME/bin/$__EXEC_REL_NAME" $@
29 |     _exit_status=$?
30 |     rm -rf "$__EXEC_TARGET_DIR"
31 |     exit $_exit_status
32 | fi
33 | __DATA_BEGIN__
34 | 


--------------------------------------------------------------------------------
/priv/templates/release_rc_entry.eex:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | set -e
 4 | 
 5 | unset CDPATH
 6 | 
 7 | SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 8 | REL_NAME="${REL_NAME:-<%= release_name %>}"
 9 | 
10 | IS_TTY=false
11 | if [ -t 1 ]; then
12 |     if command -v tput >/dev/null; then
13 |         IS_TTY=true
14 |     fi
15 | fi
16 | if [ "$IS_TTY" = "true" ]; then
17 |     txtrst=$(tput sgr0 || echo "\e[0m")              # Reset
18 |     txtbld=$(tput bold || echo "\e[1m")              # Bold
19 |     bldred=${txtbld}$(tput setaf 1 || echo "\e[31m") # Red
20 | else
21 |     txtrst=
22 |     txtbld=
23 |     bldred=
24 | fi
25 | 
26 | if ! command -v bash >/dev/null ; then
27 |     message="Bash is required to run this release. Please ensure that it is installed."
28 |     printf "${bldred}%s${txtrst}\n" "$message"
29 |     exit 1
30 | else
31 |     exec "${SCRIPT_DIR}/${REL_NAME}_rc_exec.sh" "$@"
32 | fi
33 | 


--------------------------------------------------------------------------------
/priv/templates/release_rc_exec.eex:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | unset CDPATH
 6 | 
 7 | SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 8 | RELEASE_ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 9 | RELEASES_DIR="${RELEASE_ROOT_DIR}/releases"
10 | RELEASE_MUTABLE_DIR="${RELEASE_MUTABLE_DIR:-"${RELEASE_ROOT_DIR}/var"}"
11 | START_ERL_DATA="${RELEASE_MUTABLE_DIR}/start_erl.data"
12 | REL_NAME="${REL_NAME:-<%= release_name %>}"
13 | 
14 | if [ ! -d "${RELEASE_MUTABLE_DIR}" ]; then
15 |     mkdir -p $RELEASE_MUTABLE_DIR
16 | fi
17 | if [[ "${RELEASES_DIR}/start_erl.data" -nt "${START_ERL_DATA}" ]]; then
18 |     cp "${RELEASES_DIR}/start_erl.data" "${START_ERL_DATA}"
19 | fi
20 | REL_VSN="${REL_VSN:-$(cut -d' ' -f2 "${START_ERL_DATA}")}"
21 | ERTS_VSN="${ERTS_VSN:-$(cut -d' ' -f1 "${START_ERL_DATA}")}"
22 | <%= if (include_erts == false or is_nil(erts_vsn)) do %>USE_HOST_ERTS=true<% end %>
23 | 
24 | export RELEASE_ROOT_DIR
25 | export RELEASES_DIR
26 | export RELEASE_MUTABLE_DIR
27 | export START_ERL_DATA
28 | export REL_NAME
29 | export REL_VSN
30 | export ERTS_VSN
31 | export DEBUG_BOOT
32 | 
33 | # Set DEBUG_BOOT to output verbose debugging info during execution
34 | if [ ! -z "$DEBUG_BOOT" ]; then
35 |     export PS4='+\D{%s} '
36 |     set -x
37 | fi
38 | 
39 | # Ensure TERM is set to something usable
40 | # for remote shells. The only time we'll
41 | # override this value is if it is set to "dumb"
42 | export TERM="${TERM:-xterm}"
43 | if [ "$TERM" = "dumb" ]; then
44 |     TERM=xterm
45 | fi
46 | 
47 | exec "$RELEASES_DIR/$REL_VSN/$REL_NAME.sh" "$@"
48 | 


--------------------------------------------------------------------------------
/priv/templates/release_rc_win_exec.eex:
--------------------------------------------------------------------------------
 1 | :: Discover the current release directory from the directory
 2 | :: of this script and the start_erl.data file
 3 | @echo off
 4 | set script_dir=%~dp0
 5 | for %%A in ("%script_dir%\..") do (
 6 |   set release_root_dir=%%~fA
 7 | )
 8 | set rel_name=<%= release_name %>
 9 | set rel_vsn=<%= release_version %>
10 | set boot_script=%release_root_dir%\releases\%rel_vsn%\%rel_name%.ps1
11 | 
12 | :: Use pwsh.exe rather than powershell.exe if available
13 | set prog=powershell
14 | where pwsh >nul 2>nul
15 | if %ERRORLEVEL% equ 0 (
16 |   set prog=pwsh
17 | )
18 | %prog% -NonInteractive -NoProfile -ExecutionPolicy Bypass -Command "& '%boot_script%' @args" %*
19 | 


--------------------------------------------------------------------------------
/priv/templates/vm.args.default.eex:
--------------------------------------------------------------------------------
 1 | ## This file provide the arguments provided to the VM at startup
 2 | ## You can find a full list of flags and their behaviours at
 3 | ## http://erlang.org/doc/man/erl.html
 4 | 
 5 | ## Name of the node
 6 | -name <%%= release_name %>@127.0.0.1
 7 | 
 8 | ## Cookie for distributed erlang
 9 | -setcookie <%%= release.profile.cookie %>
10 | 
11 | ## Heartbeat management; auto-restarts VM if it dies or becomes unresponsive
12 | ## (Disabled by default..use with caution!)
13 | ##-heart
14 | 
15 | ## Enable kernel poll and a few async threads
16 | ##+K true
17 | ##+A 5
18 | ## For OTP21+, the +A flag is not used anymore,
19 | ## +SDio replace it to use dirty schedulers
20 | ##+SDio 5
21 | 
22 | ## Increase number of concurrent ports/sockets
23 | ##-env ERL_MAX_PORTS 4096
24 | 
25 | ## Tweak GC to run more often
26 | ##-env ERL_FULLSWEEP_AFTER 10
27 | 
28 | # Enable SMP automatically based on availability
29 | # On OTP21+, this is not needed anymore.
30 | -smp auto
31 | 


--------------------------------------------------------------------------------
/priv/templates/vm.args.eex:
--------------------------------------------------------------------------------
 1 | ## Name of the node
 2 | -name <%= release_name %>@127.0.0.1
 3 | 
 4 | ## Cookie for distributed erlang
 5 | -setcookie <%= release.profile.cookie %>
 6 | 
 7 | ## Heartbeat management; auto-restarts VM if it dies or becomes unresponsive
 8 | ## (Disabled by default..use with caution!)
 9 | ##-heart
10 | 
11 | ## Enable kernel poll and a few async threads
12 | ##+K true
13 | ##+A 5
14 | ## For OTP21+, the +A flag is not used anymore,
15 | ## +SDio replace it to use dirty schedulers
16 | ##+SDio 5
17 | 
18 | ## Increase number of concurrent ports/sockets
19 | ##-env ERL_MAX_PORTS 4096
20 | 
21 | ## Tweak GC to run more often
22 | ##-env ERL_FULLSWEEP_AFTER 10
23 | 
24 | # Enable SMP automatically based on availability
25 | -smp auto
26 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | mkdocs==1.0
2 | git+git://github.com/bitwalker/mkdocs-material.git@master#egg=mkdocs-material
3 | pygments
4 | pymdown-extensions
5 | 


--------------------------------------------------------------------------------
/test/cases/archive_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.ArchiveTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias Distillery.Releases.Utils
 5 |   alias Distillery.Releases.Archiver.Archive
 6 | 
 7 |   setup do
 8 |     context = [
 9 |       working_dir: Utils.insecure_mkdir_temp!(),
10 |       extract_dir: Utils.insecure_mkdir_temp!()
11 |     ]
12 | 
13 |     for {_, path} <- context, do: File.mkdir_p!(path)
14 | 
15 |     on_exit(fn ->
16 |       for {_, path} <- context do
17 |         _ = File.rm_rf(path)
18 |       end
19 |     end)
20 | 
21 |     context
22 |   end
23 | 
24 |   test "creating an archive behaves as expected", %{
25 |     working_dir: working_dir,
26 |     extract_dir: extract_dir
27 |   } do
28 |     File.mkdir_p!(Path.join([working_dir, "foo", "bar"]))
29 | 
30 |     baz_path = Path.join([working_dir, "foo", "bar", "baz.txt"])
31 |     File.write!(baz_path, "hello!\n")
32 |     qux_path = Path.join([working_dir, "qux.txt"])
33 |     File.write!(qux_path, "hello again!\n")
34 |     test_file_path = __ENV__.file
35 | 
36 |     archive = Archive.new("archive_test", working_dir)
37 |     assert %Archive{name: "archive_test", working_dir: ^working_dir, manifest: %{}} = archive
38 | 
39 |     archive = Archive.add(archive, baz_path)
40 |     assert %{"foo/bar/baz.txt" => ^baz_path} = archive.manifest
41 | 
42 |     archive = Archive.add(archive, qux_path)
43 |     assert %{"qux.txt" => ^qux_path} = archive.manifest
44 | 
45 |     archive = Archive.add(archive, test_file_path, "test.exs")
46 |     assert %{"test.exs" => ^test_file_path} = archive.manifest
47 | 
48 |     {:ok, target_path} = Archive.save(archive, working_dir)
49 | 
50 |     assert File.exists?(target_path)
51 | 
52 |     {:ok, extracted} = Archive.extract(target_path, extract_dir)
53 | 
54 |     assert extracted.name == archive.name
55 |     assert extracted.working_dir == extract_dir
56 | 
57 |     assert File.exists?(extracted.manifest["test.exs"])
58 |     assert File.exists?(Path.join([extract_dir, "test.exs"]))
59 | 
60 |     assert File.exists?(extracted.manifest["qux.txt"])
61 |     assert File.exists?(Path.join([extract_dir, "qux.txt"]))
62 |     assert "hello again!\n" == File.read!(extracted.manifest["qux.txt"])
63 | 
64 |     assert File.exists?(Path.join([extract_dir, "foo", "bar", "baz.txt"]))
65 |     assert File.exists?(extracted.manifest["foo/bar/baz.txt"])
66 |     assert "hello!\n" == File.read!(extracted.manifest["foo/bar/baz.txt"])
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/test/cases/config_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.ConfigTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias Distillery.Releases.{Config, Environment, Release, Profile}
 5 | 
 6 |   @fixtures_path Path.join([__DIR__, "..", "fixtures"])
 7 |   @standard_app Path.join([@fixtures_path, "standard_app"])
 8 | 
 9 |   describe "standard app" do
10 |     test "read!" do
11 |       config =
12 |         Mix.Project.in_project(:standard_app, @standard_app, fn _mixfile ->
13 |           Distillery.Releases.Config.read!(Path.join([@standard_app, "rel", "config.exs"]))
14 |         end)
15 | 
16 |       assert %Config{
17 |                environments: %{
18 |                  dev: %Environment{profile: %Profile{dev_mode: true, include_erts: false}},
19 |                  prod: %Environment{
20 |                    profile: %Profile{dev_mode: false, include_erts: true, strip_debug_info: false}
21 |                  }
22 |                },
23 |                releases: %{
24 |                  standard_app: %Release{
25 |                    version: "0.0.1",
26 |                    applications: [
27 |                      :elixir,
28 |                      :iex,
29 |                      :mix,
30 |                      :sasl,
31 |                      :runtime_tools,
32 |                      :distillery,
33 |                    ]
34 |                  }
35 |                },
36 |                default_release: :default,
37 |                default_environment: :dev
38 |              } = config
39 |     end
40 | 
41 |     test "read_string!" do
42 |       config =
43 |         """
44 |         use Distillery.Releases.Config
45 | 
46 |         release :distillery do
47 |           set version: current_version(:distillery)
48 |         end
49 |         """
50 |         |> Distillery.Releases.Config.read_string!()
51 | 
52 |       distillery_ver = Keyword.fetch!(Mix.Project.config(), :version)
53 | 
54 |       assert %Config{
55 |                environments: %{
56 |                  default: %Environment{}
57 |                },
58 |                releases: %{
59 |                  distillery: %Release{version: ^distillery_ver}
60 |                },
61 |                default_release: :default,
62 |                default_environment: :default
63 |              } = config
64 |     end
65 |   end
66 | 
67 |   describe "plugin config" do
68 |     test "read!" do
69 |       config =
70 |         Mix.Project.in_project(:standard_app, @standard_app, fn _mixfile ->
71 |           Distillery.Releases.Config.read!(Path.join([@standard_app, "rel", "config.exs"]))
72 |         end)
73 | 
74 |       rel_plugins = [
75 |         {SampleApp.EnvLoggerPlugin, []},
76 |       ]
77 |       prod_plugins = [
78 |         {SampleApp.EnvLoggerPlugin, [name: ProdPlugin]}
79 |       ]
80 | 
81 |       assert %Config{
82 |         environments: %{
83 |           dev: %Environment{profile: %Profile{plugins: []}},
84 |           prod: %Environment{profile: %Profile{plugins: ^prod_plugins}}
85 |         },
86 |         releases: %{
87 |           standard_app: %Release{profile: %Profile{plugins: ^rel_plugins}}
88 |         }
89 |       } = config
90 |     end
91 |   end
92 | end
93 | 


--------------------------------------------------------------------------------
/test/cases/cookies_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.CookiesTest do
 2 |   use ExUnit.Case, async: true
 3 |   use EQC.ExUnit
 4 | 
 5 |   @tag numtests: 100
 6 |   property "generated cookies are always valid" do
 7 |     forall cookie <- generated_cookie() do
 8 |       is_valid_cookie(cookie)
 9 |     end
10 |   end
11 | 
12 |   test "can parse cookie via command line" do
13 |     assert is_parsed_by_command_line(Distillery.Cookies.generate())
14 |   end
15 | 
16 |   def generated_cookie() do
17 |     lazy do
18 |       Distillery.Cookies.generate()
19 |     end
20 |   end
21 | 
22 |   defp is_valid_cookie(x) when is_atom(x) do
23 |     str = Atom.to_string(x)
24 |     chars = String.to_charlist(str)
25 | 
26 |     with false <- String.contains?(str, ["-", "+", "'", "\"", "\\", "#", ","]),
27 |          false <- Enum.any?(chars, fn b -> not (b >= ?! && b <= ?~) end),
28 |          64 <- byte_size(str) do
29 |       true
30 |     else
31 |       _ -> false
32 |     end
33 |   end
34 | 
35 |   defp is_valid_cookie(_x), do: false
36 | 
37 |   defp is_parsed_by_command_line(cookie) do
38 |     cookie = Atom.to_string(cookie)
39 | 
40 |     case System.cmd("erl", ["-hidden", "-setcookie", cookie, "-noshell", "-s", "erlang", "halt"]) do
41 |       {_, 0} -> true
42 |       _ -> false
43 |     end
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------
/test/cases/provider_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.ProviderTest do
 2 |   use ExUnit.Case
 3 |   
 4 |   alias Distillery.Releases.Config.Providers
 5 |   
 6 |   @fixtures_path Path.join([__DIR__, "..", "fixtures"])
 7 |   @umbrella_config_path Path.join([@fixtures_path, "umbrella_app", "config", "config.exs"])
 8 |   @web_config_path Path.join([@fixtures_path, "umbrella_app", "apps", "web", "config", "config.exs"])
 9 |   
10 |   describe "with umbrella app" do
11 |     test "can read config with expected results" do
12 |       config = Providers.Elixir.eval!(@umbrella_config_path)
13 |       assert Web = get_in(config, [:web, :namespace])
14 |     end
15 |   end
16 |   
17 |   describe "with standard app" do
18 |     test "can read config with expected results" do
19 |       config = Providers.Elixir.eval!(@web_config_path)
20 |       assert Web = get_in(config, [:web, :namespace])
21 |     end
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/test/cases/release_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.ReleaseTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   import Distillery.Test.Helpers
 5 | 
 6 |   @fixtures_path Path.join([__DIR__, "..", "fixtures"])
 7 |   @app_path Path.join([@fixtures_path, "ordered_app"])
 8 |   @build_path Path.join([@app_path, "_build"])
 9 |   @boot_script Path.join([
10 |                   @build_path,
11 |                   "prod",
12 |                   "rel",
13 |                   "ordered_app",
14 |                   "releases",
15 |                   "0.1.0",
16 |                   "ordered_app.script"
17 |                 ])
18 | 
19 |   setup do
20 |     on_exit fn ->
21 |       File.rm_rf(@build_path)
22 |     end
23 |   end
24 | 
25 |   test "release ordered app" do
26 |     old_dir = File.cwd!()
27 |     File.cd!(@app_path)
28 |     try do
29 |       assert {:ok, _} = mix("deps.get")
30 |       assert {:ok, _} = build_release(no_tar: true)
31 | 
32 |       {:ok, [{:script, _, lines}]} = :file.consult(@boot_script)
33 | 
34 |       prios =
35 |         Enum.filter(lines, fn
36 |           {:apply, {:application, :start_boot, _}} -> true
37 |           _ -> false
38 |         end)
39 |         |> Enum.map(fn {:apply, {:application, :start_boot, [name | _]}} -> name end)
40 |         |> Enum.with_index()
41 | 
42 |       assert 0 == prios[:kernel]
43 |       assert 1 == prios[:stdlib]
44 |       assert prios[:db_connection] > prios[:connection]
45 |       assert prios[:ordered_app] > prios[:db_connection]
46 |       assert prios[:ordered_app] > prios[:lager]
47 |     after
48 |       File.cd!(old_dir)
49 |     end
50 |   end
51 | end
52 | 


--------------------------------------------------------------------------------
/test/cases/test_helper.exs:
--------------------------------------------------------------------------------
1 | if System.get_env("VERBOSE_TESTS") do
2 |   IO.puts "Working directory for tests is: #{File.cwd!}"
3 | end
4 | ExUnit.start()
5 | 


--------------------------------------------------------------------------------
/test/cases/utils_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Distillery.Test.UtilsTest do
2 |   use ExUnit.Case
3 |   doctest Distillery.Releases.Utils
4 | end
5 | 


--------------------------------------------------------------------------------
/test/fixtures/.gitignore:
--------------------------------------------------------------------------------
1 | **/*/mix.lock
2 | 


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/.compile.protocols:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/.compile.protocols


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Collectable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Collectable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Enumerable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Enumerable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.IEx.Info.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.IEx.Info.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Inspect.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Inspect.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.List.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.List.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Poison.Decoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Poison.Decoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Poison.Encoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Poison.Encoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.String.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.String.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Timex.Comparable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Timex.Comparable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Timex.Convertable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/consolidated/Elixir.Timex.Convertable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.Server.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.Server.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.Supervisor.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.Supervisor.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.1.0/ebin/Elixir.Test.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.1.0/ebin/test.app:
--------------------------------------------------------------------------------
1 | {application,test,
2 |              [{registered,[]},
3 |               {description,"test"},
4 |               {vsn,"0.1.0"},
5 |               {modules,['Elixir.Test','Elixir.Test.Server',
6 |                         'Elixir.Test.Supervisor']},
7 |               {mod,{'Elixir.Test',[]}},
8 |               {applications,[kernel,stdlib,elixir,logger,timex]}]}.


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/.compile.protocols:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/.compile.protocols


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Collectable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Collectable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Enumerable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Enumerable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.IEx.Info.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.IEx.Info.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Inspect.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Inspect.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.List.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.List.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Poison.Decoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Poison.Decoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Poison.Encoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Poison.Encoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.String.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.String.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Timex.Comparable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Timex.Comparable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Timex.Protocol.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/consolidated/Elixir.Timex.Protocol.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.Server.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.Server.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.ServerB.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.ServerB.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.ServerC.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.ServerC.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.Supervisor.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.Supervisor.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.2.0/ebin/Elixir.Test.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.2.0/ebin/test.app:
--------------------------------------------------------------------------------
1 | {application,test,
2 |              [{registered,[]},
3 |               {description,"test"},
4 |               {vsn,"0.2.0"},
5 |               {modules,['Elixir.Test','Elixir.Test.Server',
6 |                         'Elixir.Test.ServerB','Elixir.Test.ServerC',
7 |                         'Elixir.Test.Supervisor']},
8 |               {mod,{'Elixir.Test',[]}},
9 |               {applications,[kernel,stdlib,elixir,logger,timex]}]}.


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/.compile.protocols:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/.compile.protocols


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Collectable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Collectable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Enumerable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Enumerable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.IEx.Info.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.IEx.Info.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Inspect.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Inspect.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.List.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.List.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Poison.Decoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Poison.Decoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Poison.Encoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Poison.Encoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.String.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.String.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Timex.Comparable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Timex.Comparable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Timex.Protocol.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/consolidated/Elixir.Timex.Protocol.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.Server.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.Server.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.ServerB.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.ServerB.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.ServerC.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.ServerC.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.Supervisor.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.Supervisor.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-0.3.0/ebin/Elixir.Test.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-0.3.0/ebin/test.app:
--------------------------------------------------------------------------------
1 | {application,test,
2 |              [{registered,[]},
3 |               {description,"test"},
4 |               {vsn,"0.3.0"},
5 |               {modules,['Elixir.Test','Elixir.Test.Server',
6 |                         'Elixir.Test.ServerB','Elixir.Test.ServerC',
7 |                         'Elixir.Test.Supervisor']},
8 |               {mod,{'Elixir.Test',[]}},
9 |               {applications,[kernel,stdlib,elixir,logger,timex]}]}.


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/.compile.protocols:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/.compile.protocols


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Collectable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Collectable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Enumerable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Enumerable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.IEx.Info.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.IEx.Info.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Inspect.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Inspect.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.List.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.List.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Poison.Decoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Poison.Decoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Poison.Encoder.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Poison.Encoder.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.String.Chars.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.String.Chars.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Timex.Comparable.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Timex.Comparable.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Timex.Protocol.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/consolidated/Elixir.Timex.Protocol.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.Server.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.Server.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.ServerB.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.ServerB.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.ServerC.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.ServerC.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.Supervisor.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.Supervisor.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.beam:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/appup_beams/test-appup/ebin/Elixir.Test.beam


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/ebin/test.app:
--------------------------------------------------------------------------------
 1 | {application,test,
 2 |              [{registered,[]},
 3 |               {description,"test"},
 4 |               {vsn,"0.3.0"},
 5 |               {modules,['Elixir.Test','Elixir.Test.Server',
 6 |                         'Elixir.Test.ServerB','Elixir.Test.ServerC',
 7 |                         'Elixir.Test.Supervisor']},
 8 |               {mod,{'Elixir.Test',[]}},
 9 |               {applications,[kernel,stdlib,elixir,logger,timex]}]}.
10 | 


--------------------------------------------------------------------------------
/test/fixtures/appup_beams/test-appup/priv/appups/1.0.0_to_2.0.0.appup:
--------------------------------------------------------------------------------
1 | {"2.0.0",
2 |  [{"1.0.0",[{update,'Elixir.Test.Server',{advanced,[]},[]}]}],
3 |  [{"1.0.0",[{update,'Elixir.Test.Server',{advanced,[]},[]}]}]}.
4 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 |   inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | ctrl_app-*.tar
24 | 
25 | # Release definition
26 | ctrl_app.rel
27 | 
28 | # Boot script
29 | ctrl_app.boot
30 | 
31 | # Boot script source
32 | ctrl_app.script
33 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/README.md:
--------------------------------------------------------------------------------
 1 | # CtrlApp
 2 | 
 3 | **TODO: Add description**
 4 | 
 5 | ## Installation
 6 | 
 7 | If [available in Hex](https://hex.pm/docs/publish), the package can be installed
 8 | by adding `ctrl_app` to your list of dependencies in `mix.exs`:
 9 | 
10 | ```elixir
11 | def deps do
12 |   [
13 |     {:ctrl_app, "~> 0.1.0"}
14 |   ]
15 | end
16 | ```
17 | 
18 | Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
19 | and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
20 | be found at [https://hexdocs.pm/ctrl_app](https://hexdocs.pm/ctrl_app).
21 | 
22 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | use Mix.Config
 4 | 
 5 | # This configuration is loaded before any dependency and is restricted
 6 | # to this project. If another project depends on this project, this
 7 | # file won't be loaded nor affect the parent project. For this reason,
 8 | # if you want to provide default values for your application for
 9 | # 3rd-party users, it should be done in your "mix.exs" file.
10 | 
11 | # You can configure your application as:
12 | #
13 | #     config :ctrl_app, key: :value
14 | #
15 | # and access this configuration in your application as:
16 | #
17 | #     Application.get_env(:ctrl_app, :key)
18 | #
19 | # You can also configure a 3rd-party app:
20 | #
21 | #     config :logger, level: :info
22 | #
23 | 
24 | # It is also possible to import configuration files, relative to this
25 | # directory. For example, you can emulate configuration per environment
26 | # by uncommenting the line below and defining dev.exs, test.exs and such.
27 | # Configuration from the imported file will override the ones defined
28 | # here (which is why it is important to import them last).
29 | #
30 | #     import_config "#{Mix.env}.exs"
31 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/lib/ctrl_app/application.ex:
--------------------------------------------------------------------------------
 1 | defmodule CtrlApp.Application do
 2 |   # See https://hexdocs.pm/elixir/Application.html
 3 |   # for more information on OTP Applications
 4 |   @moduledoc false
 5 | 
 6 |   use Application
 7 | 
 8 |   def start(_type, _args) do
 9 |     # List all child processes to be supervised
10 |     children = [
11 |       # Starts a worker by calling: CtrlApp.Worker.start_link(arg)
12 |       CtrlApp.Worker
13 |     ]
14 | 
15 |     # See https://hexdocs.pm/elixir/Supervisor.html
16 |     # for other strategies and supported options
17 |     opts = [strategy: :one_for_one, name: CtrlApp.Supervisor]
18 |     Supervisor.start_link(children, opts)
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/lib/ctrl_app/worker.ex:
--------------------------------------------------------------------------------
 1 | defmodule CtrlApp.Worker do
 2 |   use GenServer
 3 | 
 4 |   def start_link(_), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)
 5 |   def init(_), do: {:ok, nil}
 6 | 
 7 |   def terminate(reason, _state) do
 8 |     IO.puts("Terminating #{__MODULE__} with reason: #{inspect(reason)}")
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/test/fixtures/ctrl_app/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule CtrlApp.MixProject do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :ctrl_app,
 7 |       version: "0.1.0",
 8 |       elixir: "~> 1.6",
 9 |       start_permanent: Mix.env() == :prod,
10 |       deps: deps()
11 |     ]
12 |   end
13 | 
14 |   # Run "mix help compile.app" to learn about applications.
15 |   def application do
16 |     [
17 |       extra_applications: [:logger],
18 |       mod: {CtrlApp.Application, []}
19 |     ]
20 |   end
21 | 
22 |   # Run "mix help deps" to learn about dependencies.
23 |   defp deps do
24 |     [
25 |       # {:dep_from_hexpm, "~> 0.3.0"},
26 |       # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"},
27 |     ]
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/test/fixtures/files/eval_file_example.exs:
--------------------------------------------------------------------------------
1 | defmodule Foo do
2 |   def print_ok, do: IO.puts("ok from #{Node.self}")
3 | end
4 | 
5 | Foo.print_ok
6 | 


--------------------------------------------------------------------------------
/test/fixtures/files/simple.config.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 | 
3 | IO.puts "Hi from simple.config.exs!"
4 | 
5 | config :distillery,
6 |   simple: :success
7 | 


--------------------------------------------------------------------------------
/test/fixtures/files/simple.sys.config:
--------------------------------------------------------------------------------
1 | [{distillery, [{simple, success}]}].
2 | 


--------------------------------------------------------------------------------
/test/fixtures/init_test_app/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc
12 | 
13 | # If the VM crashes, it generates a dump, let's ignore it too.
14 | erl_crash.dump
15 | 
16 | # Also ignore archive artifacts (built via "mix archive.build").
17 | *.ez
18 | 


--------------------------------------------------------------------------------
/test/fixtures/init_test_app/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | use Mix.Config
 4 | 
 5 | # This configuration is loaded before any dependency and is restricted
 6 | # to this project. If another project depends on this project, this
 7 | # file won't be loaded nor affect the parent project. For this reason,
 8 | # if you want to provide default values for your application for
 9 | # 3rd-party users, it should be done in your "mix.exs" file.
10 | 
11 | # You can configure for your application as:
12 | #
13 | #     config :init_test_app, key: :value
14 | #
15 | # And access this configuration in your application as:
16 | #
17 | #     Application.get_env(:init_test_app, :key)
18 | #
19 | # Or configure a 3rd-party app:
20 | #
21 | #     config :logger, level: :info
22 | #
23 | 
24 | # It is also possible to import configuration files, relative to this
25 | # directory. For example, you can emulate configuration per environment
26 | # by uncommenting the line below and defining dev.exs, test.exs and such.
27 | # Configuration from the imported file will override the ones defined
28 | # here (which is why it is important to import them last).
29 | #
30 | #     import_config "#{Mix.env}.exs"
31 | 


--------------------------------------------------------------------------------
/test/fixtures/init_test_app/init_test_config.eex:
--------------------------------------------------------------------------------
 1 | <%=
 2 |   # Verify that the expected bindings are available in the template
 3 | 
 4 |   true = is_boolean no_docs
 5 | 
 6 |   true = is_list releases
 7 | 
 8 |   true = is_function get_cookie
 9 |   gotten_cookie = get_cookie.()
10 |   false = is_nil gotten_cookie
11 |   true = is_atom gotten_cookie
12 | 
13 |   false = is_nil cookie
14 |   true = is_atom cookie
15 | %>
16 | 


--------------------------------------------------------------------------------
/test/fixtures/init_test_app/lib/init_test_app.ex:
--------------------------------------------------------------------------------
1 | defmodule InitTestApp do
2 | end
3 | 


--------------------------------------------------------------------------------
/test/fixtures/init_test_app/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule InitTestApp.Mixfile do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [app: :init_test_app,
 6 |      version: "0.1.0",
 7 |      elixir: "~> 1.3",
 8 |      build_embedded: Mix.env == :prod,
 9 |      start_permanent: Mix.env == :prod,
10 |      deps: deps()]
11 |   end
12 | 
13 |   # Configuration for the OTP application
14 |   #
15 |   # Type "mix help compile.app" for more information
16 |   def application do
17 |     [applications: [:logger]]
18 |   end
19 | 
20 |   # Dependencies can be Hex packages:
21 |   #
22 |   #   {:mydep, "~> 0.3.0"}
23 |   #
24 |   # Or git/path repositories:
25 |   #
26 |   #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
27 |   #
28 |   # Type "mix help deps" for more examples and options
29 |   defp deps do
30 |     [{:distillery, path: "../../../."}]
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/test/fixtures/mock_app/invalid_tmpl.eex:
--------------------------------------------------------------------------------
1 | <%= foo() %>
2 | 


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/bin/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/bin/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/erts-7.2/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/erts-7.2/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/lib/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/lib/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/releases/0.1.0/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/releases/0.1.0/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/releases/0.2.0/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/releases/0.2.0/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/releases/0.2.1-1-d3adb3f/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/releases/0.2.1-1-d3adb3f/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/releases/0.2.1/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/releases/0.2.1/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/rel/mock_app/releases/0.2.2/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/mock_app/rel/mock_app/releases/0.2.2/.gitkeep


--------------------------------------------------------------------------------
/test/fixtures/mock_app/template_test.eex:
--------------------------------------------------------------------------------
1 | hi from release (<%= release_name %>)!
2 | 


--------------------------------------------------------------------------------
/test/fixtures/ordered_app/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc
12 | 
13 | # If the VM crashes, it generates a dump, let's ignore it too.
14 | erl_crash.dump
15 | 
16 | # Also ignore archive artifacts (built via "mix archive.build").
17 | *.ez
18 | 
19 | /rel/standard_app
20 | 


--------------------------------------------------------------------------------
/test/fixtures/ordered_app/config/config.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 | 


--------------------------------------------------------------------------------
/test/fixtures/ordered_app/lib/ordered_app.ex:
--------------------------------------------------------------------------------
 1 | defmodule OrderedApp do
 2 |   use Application
 3 | 
 4 |   def start(_type, _args) do
 5 |     import Supervisor.Spec, warn: false
 6 | 
 7 |     children = []
 8 | 
 9 |     opts = [strategy: :one_for_one, name: OrderedApp.Supervisor]
10 |     Supervisor.start_link(children, opts)
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/test/fixtures/ordered_app/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule OrderedApp.Mixfile do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :ordered_app,
 7 |       version: "0.1.0",
 8 |       elixir: "~> 1.3",
 9 |       start_permanent: Mix.env == :prod,
10 |       deps: deps()
11 |     ]
12 |   end
13 | 
14 |   # Run "mix help compile.app" to learn about applications.
15 |   def application do
16 |     [
17 |       mod: {OrderedApp, []},
18 |       extra_applications: []
19 |     ]
20 |   end
21 | 
22 |   # Run "mix help deps" to learn about dependencies.
23 |   defp deps do
24 |     [
25 |       {:lager, "~> 3.5"},
26 |       {:db_connection, "~> 1.1"},
27 |       {:distillery, path: "../../../."}
28 |     ]
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/test/fixtures/ordered_app/rel/config.exs:
--------------------------------------------------------------------------------
 1 | use Distillery.Releases.Config,
 2 |     default_release: :default,
 3 |     default_environment: Mix.env()
 4 | 
 5 | 
 6 | environment :dev do
 7 |   set dev_mode: true
 8 |   set include_erts: false
 9 |   set cookie: :"b:3<,[s&!Itebrv,|sM;n3MvkmG4a0uF`R@4Zh7~VSv&*$5xh_=h~KBg/bq*k`*~"
10 | end
11 | 
12 | environment :prod do
13 |   set include_erts: false
14 |   set include_src: false
15 |   set cookie: :"UMSq<$cWFWDtMB*yl?o;7$ote.$Xcmh:z|!:]@U81}1RsDJzcC<1g8F3/g!gjom="
16 | end
17 | 
18 | 
19 | release :ordered_app do
20 |   set version: current_version(:ordered_app)
21 |   set applications: [:ordered_app]
22 | end
23 | 
24 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc
12 | 
13 | # If the VM crashes, it generates a dump, let's ignore it too.
14 | erl_crash.dump
15 | 
16 | # Also ignore archive artifacts (built via "mix archive.build").
17 | *.ez
18 | 
19 | /rel/standard_app
20 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | use Mix.Config
 4 | 
 5 | config :standard_app,
 6 |   source: :default,
 7 |   num_procs: 2
 8 | # This configuration is loaded before any dependency and is restricted
 9 | # to this project. If another project depends on this project, this
10 | # file won't be loaded nor affect the parent project. For this reason,
11 | # if you want to provide default values for your application for
12 | # 3rd-party users, it should be done in your "mix.exs" file.
13 | 
14 | # You can configure for your application as:
15 | #
16 | #     config :standard_app, key: :value
17 | #
18 | # And access this configuration in your application as:
19 | #
20 | #     Application.get_env(:standard_app, :key)
21 | #
22 | # Or configure a 3rd-party app:
23 | #
24 | #     config :logger, level: :info
25 | #
26 | 
27 | # It is also possible to import configuration files, relative to this
28 | # directory. For example, you can emulate configuration per environment
29 | # by uncommenting the line below and defining dev.exs, test.exs and such.
30 | # Configuration from the imported file will override the ones defined
31 | # here (which is why it is important to import them last).
32 | #
33 | #     import_config "#{Mix.env}.exs"
34 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/lib/standard_app.ex:
--------------------------------------------------------------------------------
 1 | defmodule StandardApp do
 2 |   use Application
 3 | 
 4 |   # See http://elixir-lang.org/docs/stable/elixir/Application.html
 5 |   # for more information on OTP Applications
 6 |   def start(_type, _args) do
 7 |     import Supervisor.Spec, warn: false
 8 | 
 9 |     # Define workers and child supervisors to be supervised
10 |     children = [
11 |       # Starts a worker by calling: StandardApp.Worker.start_link(arg1, arg2, arg3)
12 |       # worker(StandardApp.Worker, [arg1, arg2, arg3]),
13 |       worker(StandardApp.A, []),
14 |       worker(StandardApp.B, [])
15 |     ]
16 | 
17 |     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
18 |     # for other strategies and supported options
19 |     opts = [strategy: :one_for_one, name: StandardApp.Supervisor]
20 |     Supervisor.start_link(children, opts)
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/lib/standard_app/a.ex:
--------------------------------------------------------------------------------
 1 | defmodule StandardApp.A do
 2 |   use GenServer
 3 | 
 4 |   def push(item), do: GenServer.call(__MODULE__, {:push, item})
 5 |   def pop, do: GenServer.call(__MODULE__, :pop)
 6 |   def length, do: GenServer.call(__MODULE__, :length)
 7 |   def inspect, do: GenServer.call(__MODULE__, :state)
 8 |   def version do
 9 |     case GenServer.call(__MODULE__, :state) do
10 |       {v, _} ->
11 |         {:ok, v}
12 |     end
13 |   end
14 | 
15 |   def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)
16 | 
17 |   def init(_) do
18 |     {:ok, {1, []}}
19 |   end
20 | 
21 |   def handle_call({:push, item}, _from, {v, state}) do
22 |     {:reply, :ok, {v, [item | state]}}
23 |   end
24 | 
25 |   def handle_call(:pop, _from, {_, []} = state) do
26 |     {:reply, {:ok, nil}, state}
27 |   end
28 | 
29 |   def handle_call(:pop, _from, {v, [h | rest]}) do
30 |     {:reply, {:ok, h}, {v, rest}}
31 |   end
32 | 
33 |   def handle_call(:length, _from, {v, state}) do
34 |     {:reply, length(state), {v, state}}
35 |   end
36 |   
37 |   def handle_call(:state, _from, state) do
38 |     {:reply, state, state}
39 |   end
40 | 
41 |   def code_change({:down, _oldvsn}, {v, acc}, _extra) do
42 |     {:ok, {v - 1, acc}}
43 |   end
44 | 
45 |   def code_change(_oldvsn, {v, acc}, _extra) do
46 |     {:ok, {v + 1, acc}}
47 |   end
48 | end
49 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/lib/standard_app/b.ex:
--------------------------------------------------------------------------------
 1 | defmodule StandardApp.B do
 2 |   def push(item), do: do_call({:push, item})
 3 |   def pop, do: do_call(:pop)
 4 |   def length, do: do_call(:length)
 5 |   def inspect, do: do_call(:state)
 6 |   def version do
 7 |     case do_call(:state) do
 8 |       {v, _} ->
 9 |         {:ok, v}
10 |     end
11 |   end
12 | 
13 |   defp do_call(message) do
14 |     send(__MODULE__, {self(), message})
15 | 
16 |     receive do
17 |       reply -> reply
18 |     after
19 |       5_000 ->
20 |         {:error, :timeout}
21 |     end
22 |   end
23 | 
24 |   def start_link() do
25 |     :proc_lib.start_link(__MODULE__, :init, [self()])
26 |   end
27 | 
28 |   def init(parent) do
29 |     Process.register(self(), __MODULE__)
30 |     Process.flag(:trap_exit, true)
31 |     :proc_lib.init_ack(parent, {:ok, self()})
32 |     debug = :sys.debug_options([])
33 |     loop({1, []}, parent, debug)
34 |   end
35 | 
36 |   defp loop({v, acc}, parent, debug) do
37 |     receive do
38 |       {from, {:push, item}} ->
39 |         send(from, :ok)
40 |         loop({v, [item | acc]}, parent, debug)
41 | 
42 |       {from, :pop} ->
43 |         case acc do
44 |           [] ->
45 |             send(from, {:ok, nil})
46 |             loop({v, acc}, parent, debug)
47 | 
48 |           [h | rest] ->
49 |             send(from, {:ok, h})
50 |             loop({v, rest}, parent, debug)
51 |         end
52 | 
53 |       {from, :length} ->
54 |         send(from, length(acc))
55 | 
56 |       {from, :state} ->
57 |         send(from, {v, acc})
58 | 
59 |       {:system, from, req} ->
60 |         :sys.handle_system_msg(req, from, parent, __MODULE__, debug, {v, acc})
61 | 
62 |       {:EXIT, ^parent, reason} ->
63 |         exit(reason)
64 | 
65 |       msg ->
66 |         IO.inspect(msg)
67 |         loop({v, acc}, parent, debug)
68 |     end
69 |   end
70 | 
71 |   def system_continue(parent, debug, state) do
72 |     loop(state, parent, debug)
73 |   end
74 | 
75 |   def system_terminate(reason, _parent, _debug, _state) do
76 |     exit(reason)
77 |   end
78 | 
79 |   def system_get_state(state) do
80 |     {:ok, state}
81 |   end
82 | 
83 |   def system_replace_state(state_fun, state) do
84 |     new_state = state_fun.(state)
85 |     {:ok, new_state, new_state}
86 |   end
87 | 
88 |   def system_code_change({v, acc}, _module, {:down, _}, _extra) do
89 |     {:ok, {v - 1, acc}}
90 |   end
91 | 
92 |   def system_code_change({v, acc}, _module, _oldvsn, _extra) do
93 |     {:ok, {v + 1, acc}}
94 |   end
95 | end
96 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule StandardApp.Mixfile do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [app: :standard_app,
 6 |      version: "0.0.1",
 7 |      elixir: "~> 1.3",
 8 |      build_embedded: Mix.env == :prod,
 9 |      start_permanent: Mix.env == :prod,
10 |      deps: deps()]
11 |   end
12 | 
13 |   # Configuration for the OTP application
14 |   #
15 |   # Type "mix help compile.app" for more information
16 |   def application do
17 |     [applications: [:logger],
18 |      mod: {StandardApp, []}]
19 |   end
20 | 
21 |   # Dependencies can be Hex packages:
22 |   #
23 |   #   {:mydep, "~> 0.3.0"}
24 |   #
25 |   # Or git/path repositories:
26 |   #
27 |   #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
28 |   #
29 |   # Type "mix help deps" for more examples and options
30 |   defp deps do
31 |     [{:distillery, path: "../../../."}]
32 |   end
33 | end
34 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/rel/config.exs:
--------------------------------------------------------------------------------
 1 | ~w(rel plugins *.exs)
 2 | |> Path.join()
 3 | |> Path.wildcard()
 4 | |> Enum.map(&Code.eval_file(&1))
 5 | 
 6 | use Distillery.Releases.Config,
 7 |     # This sets the default release built by `mix distillery.release`
 8 |     default_release: :default,
 9 |     # This sets the default environment used by `mix distillery.release`
10 |     default_environment: :dev
11 | 
12 | # For a full list of config options for both releases
13 | # and environments, visit https://hexdocs.pm/distillery/config/distillery.html
14 | 
15 | 
16 | # You may define one or more environments in this file,
17 | # an environment's settings will override those of a release
18 | # when building in that environment, this combination of release
19 | # and environment configuration is called a profile
20 | 
21 | environment :dev do
22 |   set dev_mode: true
23 |   set include_erts: false
24 |   set cookie: :"&tNN%@WG3w]R7Ta).Ynkyamh^l0>sG1@1LFd!).=p:39^;T,eg[Ic]*:BDtF,eiT"
25 | end
26 | 
27 | environment :prod do
28 |   set dev_mode: false
29 |   set strip_debug_info: false
30 |   set include_erts: true
31 |   set include_src: false
32 |   set included_configs: ["extra.config"]
33 |   set cookie: :"*GU1?EY8/~,K!9*Ohazv{O9<Ao@)pMFFKjs/q=$HlMo~q=s!~,O8!DIs0PT(v&;="
34 |   set run_erl_env: "RUN_ERL_LOG_MAXSIZE=100000 RUN_ERL_LOG_GENERATIONS=5"
35 | 
36 |   plugin SampleApp.EnvLoggerPlugin, name: ProdPlugin
37 | end
38 | 
39 | # You may define one or more releases in this file.
40 | # If you have not set a default release, or selected one
41 | # when running `mix distillery.release`, the first release in the file
42 | # will be used by default
43 | 
44 | release :standard_app do
45 |   set version: "0.0.1"
46 |   
47 |   set config_providers: [
48 |     {Distillery.Releases.Config.Providers.Elixir, ["${REL_DIR}/config.exs"]}
49 |   ]
50 |   
51 |   set overlays: [
52 |     {:copy, "rel/config/config.exs", "releases/<%= release_version %>/config.exs"}
53 |   ]
54 | 
55 |   plugin SampleApp.EnvLoggerPlugin
56 | end
57 | 
58 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/rel/config/config.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 | 
3 | config :standard_app,
4 |   source: :config_provider
5 | 


--------------------------------------------------------------------------------
/test/fixtures/standard_app/rel/plugins/env_logger.exs:
--------------------------------------------------------------------------------
 1 | defmodule SampleApp.EnvLoggerPlugin do
 2 |   use Distillery.Releases.Plugin
 3 |   
 4 |   def before_assembly(release, opts), do: log(release, opts, elem(__ENV__.function, 0))
 5 |   def after_assembly(release, opts), do: log(release, opts, elem(__ENV__.function, 0))
 6 |   def before_package(release, opts), do: log(release, opts, elem(__ENV__.function, 0))
 7 |   def after_package(release, opts), do: log(release, opts, elem(__ENV__.function, 0))
 8 |   def after_cleanup(release, opts), do: log(release, opts, elem(__ENV__.function, 0))
 9 |   
10 |   defp log(%Distillery.Releases.Release{env: env}, opts, callback) do
11 |     name = Keyword.get(opts, :name, __MODULE__)
12 |     info("#{name} in #{env} executing #{callback}")
13 |     nil
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 |   inputs: ["mix.exs", "config/*.exs"],
4 |   subdirectories: ["apps/*"]
5 | ]
6 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/README.md:
--------------------------------------------------------------------------------
1 | # Distillery Umbrella Test
2 | 
3 | This is just a simple umbrella application with a Phoenix app for testing Distillery
4 | 
5 | ## License
6 | 
7 | Apache 2
8 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/.gitignore:
--------------------------------------------------------------------------------
 1 | # App artifacts
 2 | /_build
 3 | /db
 4 | /deps
 5 | /*.ez
 6 | 
 7 | # Generated on crash by the VM
 8 | erl_crash.dump
 9 | 
10 | # Generated on crash by NPM
11 | npm-debug.log
12 | 
13 | # Static artifacts
14 | /assets/node_modules
15 | 
16 | # Since we are building assets from assets/,
17 | # we ignore priv/static. You may want to comment
18 | # this depending on your deployment strategy.
19 | /priv/static/
20 | 
21 | # Files matching config/*.secret.exs pattern contain sensitive
22 | # data and you should not commit them into version control.
23 | #
24 | # Alternatively, you may comment the line below and commit the
25 | # secrets files as long as you replace their contents by environment
26 | # variables.
27 | /config/*.secret.exs


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/README.md:
--------------------------------------------------------------------------------
 1 | # Web
 2 | 
 3 | To start your Phoenix server:
 4 | 
 5 |   * Install dependencies with `mix deps.get`
 6 |   * Install Node.js dependencies with `cd assets && npm install`
 7 |   * Start Phoenix endpoint with `mix phx.server`
 8 | 
 9 | Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
10 | 
11 | Ready to run in production? Please [check our deployment guides](http://www.phoenixframework.org/docs/deployment).
12 | 
13 | ## Learn more
14 | 
15 |   * Official website: http://www.phoenixframework.org/
16 |   * Guides: http://phoenixframework.org/docs/overview
17 |   * Docs: https://hexdocs.pm/phoenix
18 |   * Mailing list: http://groups.google.com/group/phoenix-talk
19 |   * Source: https://github.com/phoenixframework/phoenix
20 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/brunch-config.js:
--------------------------------------------------------------------------------
 1 | exports.config = {
 2 |   // See http://brunch.io/#documentation for docs.
 3 |   files: {
 4 |     javascripts: {
 5 |       joinTo: "js/app.js"
 6 | 
 7 |       // To use a separate vendor.js bundle, specify two files path
 8 |       // http://brunch.io/docs/config#-files-
 9 |       // joinTo: {
10 |       //   "js/app.js": /^js/,
11 |       //   "js/vendor.js": /^(?!js)/
12 |       // }
13 |       //
14 |       // To change the order of concatenation of files, explicitly mention here
15 |       // order: {
16 |       //   before: [
17 |       //     "vendor/js/jquery-2.1.1.js",
18 |       //     "vendor/js/bootstrap.min.js"
19 |       //   ]
20 |       // }
21 |     },
22 |     stylesheets: {
23 |       joinTo: "css/app.css"
24 |     },
25 |     templates: {
26 |       joinTo: "js/app.js"
27 |     }
28 |   },
29 | 
30 |   conventions: {
31 |     // This option sets where we should place non-css and non-js assets in.
32 |     // By default, we set this to "/assets/static". Files in this directory
33 |     // will be copied to `paths.public`, which is "priv/static" by default.
34 |     assets: /^(static)/
35 |   },
36 | 
37 |   // Phoenix paths configuration
38 |   paths: {
39 |     // Dependencies and current project directories to watch
40 |     watched: ["static", "css", "js", "vendor"],
41 |     // Where to compile files to
42 |     public: "../priv/static"
43 |   },
44 | 
45 |   // Configure your plugins
46 |   plugins: {
47 |     babel: {
48 |       // Do not use ES6 compiler in vendor code
49 |       ignore: [/vendor/]
50 |     }
51 |   },
52 | 
53 |   modules: {
54 |     autoRequire: {
55 |       "js/app.js": ["js/app"]
56 |     }
57 |   },
58 | 
59 |   npm: {
60 |     enabled: true
61 |   }
62 | };
63 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/css/app.css:
--------------------------------------------------------------------------------
1 | /* This file is for your main application css. */


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/js/app.js:
--------------------------------------------------------------------------------
 1 | // Brunch automatically concatenates all files in your
 2 | // watched paths. Those paths can be configured at
 3 | // config.paths.watched in "brunch-config.js".
 4 | //
 5 | // However, those files will only be executed if
 6 | // explicitly imported. The only exception are files
 7 | // in vendor, which are never wrapped in imports and
 8 | // therefore are always executed.
 9 | 
10 | // Import dependencies
11 | //
12 | // If you no longer want to use a dependency, remember
13 | // to also remove its path from "config.paths.watched".
14 | import "phoenix_html"
15 | 
16 | // Import local files
17 | //
18 | // Local files can be imported directly using relative
19 | // paths "./socket" or full ones "web/static/js/socket".
20 | 
21 | // import socket from "./socket"
22 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/js/socket.js:
--------------------------------------------------------------------------------
 1 | // NOTE: The contents of this file will only be executed if
 2 | // you uncomment its entry in "assets/js/app.js".
 3 | 
 4 | // To use Phoenix channels, the first step is to import Socket
 5 | // and connect at the socket path in "lib/web/endpoint.ex":
 6 | import {Socket} from "phoenix"
 7 | 
 8 | let socket = new Socket("/socket", {params: {token: window.userToken}})
 9 | 
10 | // When you connect, you'll often need to authenticate the client.
11 | // For example, imagine you have an authentication plug, `MyAuth`,
12 | // which authenticates the session and assigns a `:current_user`.
13 | // If the current user exists you can assign the user's token in
14 | // the connection for use in the layout.
15 | //
16 | // In your "lib/web/router.ex":
17 | //
18 | //     pipeline :browser do
19 | //       ...
20 | //       plug MyAuth
21 | //       plug :put_user_token
22 | //     end
23 | //
24 | //     defp put_user_token(conn, _) do
25 | //       if current_user = conn.assigns[:current_user] do
26 | //         token = Phoenix.Token.sign(conn, "user socket", current_user.id)
27 | //         assign(conn, :user_token, token)
28 | //       else
29 | //         conn
30 | //       end
31 | //     end
32 | //
33 | // Now you need to pass this token to JavaScript. You can do so
34 | // inside a script tag in "lib/web/templates/layout/app.html.eex":
35 | //
36 | //     <script>window.userToken = "<%= assigns[:user_token] %>";</script>
37 | //
38 | // You will need to verify the user token in the "connect/2" function
39 | // in "lib/web/channels/user_socket.ex":
40 | //
41 | //     def connect(%{"token" => token}, socket) do
42 | //       # max_age: 1209600 is equivalent to two weeks in seconds
43 | //       case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
44 | //         {:ok, user_id} ->
45 | //           {:ok, assign(socket, :user, user_id)}
46 | //         {:error, reason} ->
47 | //           :error
48 | //       end
49 | //     end
50 | //
51 | // Finally, pass the token on connect as below. Or remove it
52 | // from connect if you don't care about authentication.
53 | 
54 | socket.connect()
55 | 
56 | // Now that you are connected, you can join channels with a topic:
57 | let channel = socket.channel("topic:subtopic", {})
58 | channel.join()
59 |   .receive("ok", resp => { console.log("Joined successfully", resp) })
60 |   .receive("error", resp => { console.log("Unable to join", resp) })
61 | 
62 | export default socket
63 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "repository": {},
 3 |   "license": "MIT",
 4 |   "scripts": {
 5 |     "deploy": "brunch build --production",
 6 |     "watch": "brunch watch --stdin"
 7 |   },
 8 |   "dependencies": {
 9 |     "phoenix": "file:../../../deps/phoenix",
10 |     "phoenix_html": "file:../../../deps/phoenix_html"
11 |   },
12 |   "devDependencies": {
13 |     "babel-brunch": "6.1.1",
14 |     "brunch": "2.10.9",
15 |     "clean-css-brunch": "2.10.0",
16 |     "uglify-js-brunch": "2.10.0"
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/umbrella_app/apps/web/assets/static/favicon.ico


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitwalker/distillery/3ab4d6146c7bc18139ed75d330e4fbb0fceb7591/test/fixtures/umbrella_app/apps/web/assets/static/images/phoenix.png


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | #
 4 | # This configuration file is loaded before any dependency and
 5 | # is restricted to this project.
 6 | use Mix.Config
 7 | 
 8 | # General application configuration
 9 | config :web,
10 |   namespace: Web
11 | 
12 | # Configures the endpoint
13 | config :web, WebWeb.Endpoint,
14 |   url: [host: "localhost"],
15 |   secret_key_base: "aFbeRKk1O9lfRsJlM9XqzsFX++i5ZmslYz2WMgS0qqTR1bvmIPgVw0Em6daZ2Q3d",
16 |   render_errors: [view: WebWeb.ErrorView, accepts: ~w(html json)],
17 |   pubsub: [name: Web.PubSub,
18 |            adapter: Phoenix.PubSub.PG2]
19 | 
20 | # Configures Elixir's Logger
21 | config :logger, :console,
22 |   format: "$time $metadata[$level] $message\n",
23 |   metadata: [:user_id]
24 | 
25 | # Import environment specific config. This must remain at the bottom
26 | # of this file so it overrides the configuration defined above.
27 | import_config "#{Mix.env}.exs"
28 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/config/dev.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # For development, we disable any cache and enable
 4 | # debugging and code reloading.
 5 | #
 6 | # The watchers configuration can be used to run external
 7 | # watchers to your application. For example, we use it
 8 | # with brunch.io to recompile .js and .css sources.
 9 | config :web, WebWeb.Endpoint,
10 |   http: [port: 4000],
11 |   debug_errors: true,
12 |   code_reloader: true,
13 |   check_origin: false,
14 |   watchers: [node: ["node_modules/brunch/bin/brunch", "watch", "--stdin",
15 |                     cd: Path.expand("../assets", __DIR__)]]
16 | 
17 | # ## SSL Support
18 | #
19 | # In order to use HTTPS in development, a self-signed
20 | # certificate can be generated by running the following
21 | # command from your terminal:
22 | #
23 | #     openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
24 | #
25 | # The `http:` config above can be replaced with:
26 | #
27 | #     https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
28 | #
29 | # If desired, both `http:` and `https:` keys can be
30 | # configured to run both http and https servers on
31 | # different ports.
32 | 
33 | # Watch static and templates for browser reloading.
34 | config :web, WebWeb.Endpoint,
35 |   live_reload: [
36 |     patterns: [
37 |       ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$},
38 |       ~r{priv/gettext/.*(po)$},
39 |       ~r{lib/web_web/views/.*(ex)$},
40 |       ~r{lib/web_web/templates/.*(eex)$}
41 |     ]
42 |   ]
43 | 
44 | # Do not include metadata nor timestamps in development logs
45 | config :logger, :console, format: "[$level] $message\n"
46 | 
47 | # Set a higher stacktrace during development. Avoid configuring such
48 | # in production as building large stacktraces may be expensive.
49 | config :phoenix, :stacktrace_depth, 20
50 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/config/prod.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # For production, we often load configuration from external
 4 | # sources, such as your system environment. For this reason,
 5 | # you won't find the :http configuration below, but set inside
 6 | # WebWeb.Endpoint.init/2 when load_from_system_env is
 7 | # true. Any dynamic configuration should be done there.
 8 | #
 9 | # Don't forget to configure the url host to something meaningful,
10 | # Phoenix uses this information when generating URLs.
11 | #
12 | # Finally, we also include the path to a cache manifest
13 | # containing the digested version of static files. This
14 | # manifest is generated by the mix phx.digest task
15 | # which you typically run after static files are built.
16 | config :web, WebWeb.Endpoint,
17 |   load_from_system_env: true,
18 |   url: [host: "example.com", port: 80],
19 |   cache_static_manifest: "priv/static/cache_manifest.json"
20 | 
21 | # Do not print debug messages in production
22 | config :logger, level: :info
23 | 
24 | # ## SSL Support
25 | #
26 | # To get SSL working, you will need to add the `https` key
27 | # to the previous section and set your `:url` port to 443:
28 | #
29 | #     config :web, WebWeb.Endpoint,
30 | #       ...
31 | #       url: [host: "example.com", port: 443],
32 | #       https: [:inet6,
33 | #               port: 443,
34 | #               keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
35 | #               certfile: System.get_env("SOME_APP_SSL_CERT_PATH")]
36 | #
37 | # Where those two env variables return an absolute path to
38 | # the key and cert in disk or a relative path inside priv,
39 | # for example "priv/ssl/server.key".
40 | #
41 | # We also recommend setting `force_ssl`, ensuring no data is
42 | # ever sent via http, always redirecting to https:
43 | #
44 | #     config :web, WebWeb.Endpoint,
45 | #       force_ssl: [hsts: true]
46 | #
47 | # Check `Plug.SSL` for all available options in `force_ssl`.
48 | 
49 | # ## Using releases
50 | #
51 | # If you are doing OTP releases, you need to instruct Phoenix
52 | # to start the server for all endpoints:
53 | #
54 | #     config :phoenix, :serve_endpoints, true
55 | #
56 | # Alternatively, you can configure exactly which server to
57 | # start per endpoint:
58 | #
59 | #     config :web, WebWeb.Endpoint, server: true
60 | #
61 | 
62 | # Finally import the config/prod.secret.exs
63 | # which should be versioned separately.
64 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/config/test.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # We don't run a server during test. If one is required,
 4 | # you can enable the server option below.
 5 | config :web, WebWeb.Endpoint,
 6 |   http: [port: 4001],
 7 |   server: false
 8 | 
 9 | # Print only warnings and errors during test
10 | config :logger, level: :warn
11 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web.ex:
--------------------------------------------------------------------------------
 1 | defmodule Web do
 2 |   @moduledoc """
 3 |   Web keeps the contexts that define your domain
 4 |   and business logic.
 5 | 
 6 |   Contexts are also responsible for managing your data, regardless
 7 |   if it comes from the database, an external API or others.
 8 |   """
 9 | end
10 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web/application.ex:
--------------------------------------------------------------------------------
 1 | defmodule Web.Application do
 2 |   use Application
 3 | 
 4 |   # See https://hexdocs.pm/elixir/Application.html
 5 |   # for more information on OTP Applications
 6 |   def start(_type, _args) do
 7 |     import Supervisor.Spec
 8 | 
 9 |     # Define workers and child supervisors to be supervised
10 |     children = [
11 |       # Start the endpoint when the application starts
12 |       supervisor(WebWeb.Endpoint, []),
13 |       # Start your own worker by calling: Web.Worker.start_link(arg1, arg2, arg3)
14 |       # worker(Web.Worker, [arg1, arg2, arg3]),
15 |     ]
16 | 
17 |     # See https://hexdocs.pm/elixir/Supervisor.html
18 |     # for other strategies and supported options
19 |     opts = [strategy: :one_for_one, name: Web.Supervisor]
20 |     Supervisor.start_link(children, opts)
21 |   end
22 | 
23 |   # Tell Phoenix to update the endpoint configuration
24 |   # whenever the application is updated.
25 |   def config_change(changed, _new, removed) do
26 |     WebWeb.Endpoint.config_change(changed, removed)
27 |     :ok
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb do
 2 |   @moduledoc """
 3 |   The entrypoint for defining your web interface, such
 4 |   as controllers, views, channels and so on.
 5 | 
 6 |   This can be used in your application as:
 7 | 
 8 |       use WebWeb, :controller
 9 |       use WebWeb, :view
10 | 
11 |   The definitions below will be executed for every view,
12 |   controller, etc, so keep them short and clean, focused
13 |   on imports, uses and aliases.
14 | 
15 |   Do NOT define functions inside the quoted expressions
16 |   below. Instead, define any helper function in modules
17 |   and import those modules here.
18 |   """
19 | 
20 |   def controller do
21 |     quote do
22 |       use Phoenix.Controller, namespace: WebWeb
23 |       import Plug.Conn
24 |       import WebWeb.Router.Helpers
25 |       import WebWeb.Gettext
26 |     end
27 |   end
28 | 
29 |   def view do
30 |     quote do
31 |       use Phoenix.View, root: "lib/web_web/templates",
32 |                         namespace: WebWeb
33 | 
34 |       # Import convenience functions from controllers
35 |       import Phoenix.Controller, only: [get_flash: 2, view_module: 1]
36 | 
37 |       # Use all HTML functionality (forms, tags, etc)
38 |       use Phoenix.HTML
39 | 
40 |       import WebWeb.Router.Helpers
41 |       import WebWeb.ErrorHelpers
42 |       import WebWeb.Gettext
43 |     end
44 |   end
45 | 
46 |   def router do
47 |     quote do
48 |       use Phoenix.Router
49 |       import Plug.Conn
50 |       import Phoenix.Controller
51 |     end
52 |   end
53 | 
54 |   def channel do
55 |     quote do
56 |       use Phoenix.Channel
57 |       import WebWeb.Gettext
58 |     end
59 |   end
60 | 
61 |   @doc """
62 |   When used, dispatch to the appropriate controller/view/etc.
63 |   """
64 |   defmacro __using__(which) when is_atom(which) do
65 |     apply(__MODULE__, which, [])
66 |   end
67 | end
68 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.UserSocket do
 2 |   use Phoenix.Socket
 3 | 
 4 |   ## Channels
 5 |   # channel "room:*", WebWeb.RoomChannel
 6 | 
 7 |   ## Transports
 8 |   transport :websocket, Phoenix.Transports.WebSocket
 9 |   # transport :longpoll, Phoenix.Transports.LongPoll
10 | 
11 |   # Socket params are passed from the client and can
12 |   # be used to verify and authenticate a user. After
13 |   # verification, you can put default assigns into
14 |   # the socket that will be set for all channels, ie
15 |   #
16 |   #     {:ok, assign(socket, :user_id, verified_user_id)}
17 |   #
18 |   # To deny connection, return `:error`.
19 |   #
20 |   # See `Phoenix.Token` documentation for examples in
21 |   # performing token verification on connect.
22 |   def connect(_params, socket) do
23 |     {:ok, socket}
24 |   end
25 | 
26 |   # Socket id's are topics that allow you to identify all sockets for a given user:
27 |   #
28 |   #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
29 |   #
30 |   # Would allow you to broadcast a "disconnect" event and terminate
31 |   # all active sockets and channels for a given user:
32 |   #
33 |   #     WebWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
34 |   #
35 |   # Returning `nil` makes this socket anonymous.
36 |   def id(_socket), do: nil
37 | end
38 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/controllers/health_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule WebWeb.HealthController do
2 |   use WebWeb, :controller
3 | 
4 |   def index(conn, _params) do
5 |     json conn, %{status: :ok}
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule WebWeb.PageController do
2 |   use WebWeb, :controller
3 | 
4 |   def index(conn, _params) do
5 |     render conn, "index.html"
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/endpoint.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.Endpoint do
 2 |   use Phoenix.Endpoint, otp_app: :web
 3 | 
 4 |   socket "/socket", WebWeb.UserSocket
 5 | 
 6 |   # Serve at "/" the static files from "priv/static" directory.
 7 |   #
 8 |   # You should set gzip to true if you are running phoenix.digest
 9 |   # when deploying your static files in production.
10 |   plug Plug.Static,
11 |     at: "/", from: :web, gzip: false,
12 |     only: ~w(css fonts images js favicon.ico robots.txt)
13 | 
14 |   # Code reloading can be explicitly enabled under the
15 |   # :code_reloader configuration of your endpoint.
16 |   if code_reloading? do
17 |     socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
18 |     plug Phoenix.LiveReloader
19 |     plug Phoenix.CodeReloader
20 |   end
21 | 
22 |   plug Plug.Logger
23 | 
24 |   plug Plug.Parsers,
25 |     parsers: [:urlencoded, :multipart, :json],
26 |     pass: ["*/*"],
27 |     json_decoder: Poison
28 | 
29 |   plug Plug.MethodOverride
30 |   plug Plug.Head
31 | 
32 |   # The session will be stored in the cookie and signed,
33 |   # this means its contents can be read but not tampered with.
34 |   # Set :encryption_salt if you would also like to encrypt it.
35 |   plug Plug.Session,
36 |     store: :cookie,
37 |     key: "_web_key",
38 |     signing_salt: "jP/XyRvz"
39 | 
40 |   plug WebWeb.Router
41 | 
42 |   @doc """
43 |   Callback invoked for dynamically configuring the endpoint.
44 | 
45 |   It receives the endpoint configuration and checks if
46 |   configuration should be loaded from the system environment.
47 |   """
48 |   def init(_key, config) do
49 |     if config[:load_from_system_env] do
50 |       port = System.get_env("PORT") || raise "expected the PORT environment variable to be set"
51 |       {:ok, Keyword.put(config, :http, [:inet6, port: port])}
52 |     else
53 |       {:ok, config}
54 |     end
55 |   end
56 | end
57 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/gettext.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.Gettext do
 2 |   @moduledoc """
 3 |   A module providing Internationalization with a gettext-based API.
 4 | 
 5 |   By using [Gettext](https://hexdocs.pm/gettext),
 6 |   your module gains a set of macros for translations, for example:
 7 | 
 8 |       import WebWeb.Gettext
 9 | 
10 |       # Simple translation
11 |       gettext "Here is the string to translate"
12 | 
13 |       # Plural translation
14 |       ngettext "Here is the string to translate",
15 |                "Here are the strings to translate",
16 |                3
17 | 
18 |       # Domain-based translation
19 |       dgettext "errors", "Here is the error message to translate"
20 | 
21 |   See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 |   """
23 |   use Gettext, otp_app: :web
24 | end
25 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/router.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.Router do
 2 |   use WebWeb, :router
 3 | 
 4 |   pipeline :browser do
 5 |     plug :accepts, ["html"]
 6 |     plug :fetch_session
 7 |     plug :fetch_flash
 8 |     plug :protect_from_forgery
 9 |     plug :put_secure_browser_headers
10 |   end
11 | 
12 |   pipeline :api do
13 |     plug :accepts, ["json"]
14 |   end
15 | 
16 |   scope "/", WebWeb do
17 |     pipe_through :browser # Use the default browser stack
18 | 
19 |     get "/", PageController, :index
20 |   end
21 | 
22 |   scope "/healthz", WebWeb do
23 |     pipe_through :api
24 |     
25 |     get "/", HealthController, :index
26 |   end
27 |   
28 | 
29 |   # Other scopes may use custom stacks.
30 |   # scope "/api", WebWeb do
31 |   #   pipe_through :api
32 |   # end
33 | end
34 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/templates/layout/app.html.eex:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <meta name="description" content="">
 8 |     <meta name="author" content="">
 9 | 
10 |     <title>Hello Web!</title>
11 |     <link rel="stylesheet" href="<%= static_path(@conn, "/css/app.css") %>">
12 |   </head>
13 | 
14 |   <body>
15 |     <div class="container">
16 |       <header class="header">
17 |         <nav role="navigation">
18 |           <ul class="nav nav-pills pull-right">
19 |             <li><a href="http://www.phoenixframework.org/docs">Get Started</a></li>
20 |           </ul>
21 |         </nav>
22 |         <span class="logo"></span>
23 |       </header>
24 | 
25 |       <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
26 |       <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
27 | 
28 |       <main role="main">
29 |         <%= render @view_module, @view_template, assigns %>
30 |       </main>
31 | 
32 |     </div> <!-- /container -->
33 |     <script src="<%= static_path(@conn, "/js/app.js") %>"></script>
34 |   </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/templates/page/index.html.eex:
--------------------------------------------------------------------------------
 1 | <div class="jumbotron">
 2 |   <h2><%= gettext "Welcome to %{name}!", name: "Phoenix" %></h2>
 3 |   <p class="lead">A productive web framework that<br />does not compromise speed and maintainability.</p>
 4 | </div>
 5 | 
 6 | <div class="row marketing">
 7 |   <div class="col-lg-6">
 8 |     <h4>Resources</h4>
 9 |     <ul>
10 |       <li>
11 |         <a href="http://phoenixframework.org/docs/overview">Guides</a>
12 |       </li>
13 |       <li>
14 |         <a href="https://hexdocs.pm/phoenix">Docs</a>
15 |       </li>
16 |       <li>
17 |         <a href="https://github.com/phoenixframework/phoenix">Source</a>
18 |       </li>
19 |     </ul>
20 |   </div>
21 | 
22 |   <div class="col-lg-6">
23 |     <h4>Help</h4>
24 |     <ul>
25 |       <li>
26 |         <a href="http://groups.google.com/group/phoenix-talk">Mailing list</a>
27 |       </li>
28 |       <li>
29 |         <a href="http://webchat.freenode.net/?channels=elixir-lang">#elixir-lang on freenode IRC</a>
30 |       </li>
31 |       <li>
32 |         <a href="https://twitter.com/elixirphoenix">@elixirphoenix</a>
33 |       </li>
34 |     </ul>
35 |   </div>
36 | </div>
37 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.ErrorHelpers do
 2 |   @moduledoc """
 3 |   Conveniences for translating and building error messages.
 4 |   """
 5 | 
 6 |   use Phoenix.HTML
 7 | 
 8 |   @doc """
 9 |   Generates tag for inlined form input errors.
10 |   """
11 |   def error_tag(form, field) do
12 |     Enum.map(Keyword.get_values(form.errors, field), fn (error) ->
13 |       content_tag :span, translate_error(error), class: "help-block"
14 |     end)
15 |   end
16 | 
17 |   @doc """
18 |   Translates an error message using gettext.
19 |   """
20 |   def translate_error({msg, opts}) do
21 |     # When using gettext, we typically pass the strings we want
22 |     # to translate as a static argument:
23 |     #
24 |     #     # Translate "is invalid" in the "errors" domain
25 |     #     dgettext "errors", "is invalid"
26 |     #
27 |     #     # Translate the number of files with plural rules
28 |     #     dngettext "errors", "1 file", "%{count} files", count
29 |     #
30 |     # Because the error messages we show in our forms and APIs
31 |     # are defined inside Ecto, we need to translate them dynamically.
32 |     # This requires us to call the Gettext module passing our gettext
33 |     # backend as first argument.
34 |     #
35 |     # Note we use the "errors" domain, which means translations
36 |     # should be written to the errors.po file. The :count option is
37 |     # set by Ecto and indicates we should also apply plural rules.
38 |     if count = opts[:count] do
39 |       Gettext.dngettext(WebWeb.Gettext, "errors", msg, msg, count, opts)
40 |     else
41 |       Gettext.dgettext(WebWeb.Gettext, "errors", msg, opts)
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/views/error_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule WebWeb.ErrorView do
 2 |   use WebWeb, :view
 3 | 
 4 |   # If you want to customize a particular status code
 5 |   # for a certain format, you may uncomment below.
 6 |   # def render("500.html", _assigns) do
 7 |   #   "Internal Server Error"
 8 |   # end
 9 | 
10 |   # By default, Phoenix returns the status message from
11 |   # the template name. For example, "404.html" becomes
12 |   # "Not Found".
13 |   def template_not_found(template, _assigns) do
14 |     Phoenix.Controller.status_message_from_template(template)
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule WebWeb.LayoutView do
2 |   use WebWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/lib/web_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule WebWeb.PageView do
2 |   use WebWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule Web.Mixfile do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :web,
 7 |       version: "0.0.1",
 8 |       build_path: "../../_build",
 9 |       config_path: "../../config/config.exs",
10 |       deps_path: "../../deps",
11 |       lockfile: "../../mix.lock",
12 |       elixir: "~> 1.4",
13 |       elixirc_paths: elixirc_paths(Mix.env),
14 |       compilers: [:phoenix, :gettext] ++ Mix.compilers,
15 |       start_permanent: Mix.env == :prod,
16 |       test_paths: [],
17 |       deps: deps()
18 |     ]
19 |   end
20 | 
21 |   # Configuration for the OTP application.
22 |   #
23 |   # Type `mix help compile.app` for more information.
24 |   def application do
25 |     [
26 |       mod: {Web.Application, []},
27 |       extra_applications: [:logger, :runtime_tools]
28 |     ]
29 |   end
30 | 
31 |   # Specifies which paths to compile per environment.
32 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
33 |   defp elixirc_paths(_),     do: ["lib"]
34 | 
35 |   # Specifies your project dependencies.
36 |   #
37 |   # Type `mix help deps` for examples and options.
38 |   defp deps do
39 |     [
40 |       {:phoenix, "~> 1.3.3"},
41 |       {:phoenix_pubsub, "~> 1.0"},
42 |       {:phoenix_html, "~> 2.10"},
43 |       {:phoenix_live_reload, "~> 1.0", only: :dev},
44 |       {:gettext, "~> 0.11"},
45 |       {:cowboy, "~> 1.0"}
46 |     ]
47 |   end
48 | end
49 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
 1 | ## `msgid`s in this file come from POT (.pot) files.
 2 | ##
 3 | ## Do not add, change, or remove `msgid`s manually here as
 4 | ## they're tied to the ones in the corresponding POT file
 5 | ## (with the same domain).
 6 | ##
 7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
 8 | ## to merge POT files into PO files.
 9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/apps/web/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
 1 | ## This file is a PO Template file.
 2 | ##
 3 | ## `msgid`s here are often extracted from source code.
 4 | ## Add new translations manually only if they're dynamic
 5 | ## translations that can't be statically extracted.
 6 | ##
 7 | ## Run `mix gettext.extract` to bring this file up to
 8 | ## date. Leave `msgstr`s empty as changing them here as no
 9 | ## effect: edit them in PO (`.po`) files instead.
10 | 
11 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | use Mix.Config
 4 | 
 5 | # By default, the umbrella project as well as each child
 6 | # application will require this configuration file, ensuring
 7 | # they all use the same configuration. While one could
 8 | # configure all applications here, we prefer to delegate
 9 | # back to each application for organization purposes.
10 | import_config "../apps/*/config/config.exs"
11 | 
12 | # Sample configuration (overrides the imported configuration above):
13 | #
14 | #     config :logger, :console,
15 | #       level: :info,
16 | #       format: "$date $time [$level] $metadata$message\n",
17 | #       metadata: [:user_id]
18 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule DistilleryUmbrellaTest.MixProject do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       apps_path: "apps",
 7 |       start_permanent: Mix.env() == :prod,
 8 |       test_paths: [],
 9 |       deps: deps()
10 |     ]
11 |   end
12 | 
13 |   # Dependencies listed here are available only for this
14 |   # project and cannot be accessed from applications inside
15 |   # the apps folder.
16 |   #
17 |   # Run "mix help deps" for examples and options.
18 |   defp deps do
19 |     [{:distillery, path: "../../../."}]
20 |   end
21 | end
22 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/rel/config.exs:
--------------------------------------------------------------------------------
 1 | # Import all plugins from `rel/plugins`
 2 | # They can then be used by adding `plugin MyPlugin` to
 3 | # either an environment, or release definition, where
 4 | # `MyPlugin` is the name of the plugin module.
 5 | ~w(rel plugins *.exs)
 6 | |> Path.join()
 7 | |> Path.wildcard()
 8 | |> Enum.map(&Code.eval_file(&1))
 9 | 
10 | use Distillery.Releases.Config,
11 |     # This sets the default release built by `mix distillery.release`
12 |     default_release: :default,
13 |     # This sets the default environment used by `mix distillery.release`
14 |     default_environment: Mix.env()
15 | 
16 | 
17 | environment :dev do
18 |   # If you are running Phoenix, you should make sure that
19 |   # server: true is set and the code reloader is disabled,
20 |   # even in dev mode.
21 |   # It is recommended that you build with MIX_ENV=prod and pass
22 |   # the --env flag to Distillery explicitly if you want to use
23 |   # dev mode.
24 |   set dev_mode: true
25 |   set include_erts: false
26 |   set cookie: :"f:okQO{}o8:7Hi^&jI4ssu{71FoJ5dFE!2Bmg}~dtzxyzpY]dmDSc!epwJ`e*k_S"
27 | end
28 | 
29 | environment :prod do
30 |   set include_erts: true
31 |   set include_src: false
32 |   set cookie: :"$^{@jVal*|$,)nJPdZNlUsMQMUEDBh7A?~U2x^>/f`J72xpa@kbm}`}QwLIHF1yR"
33 |   set vm_args: "rel/vm.args"
34 | end
35 | 
36 | 
37 | release :umbrella do
38 |   set version: "0.1.0"
39 |   set applications: [
40 |     :runtime_tools,
41 |     web: :permanent
42 |   ]
43 | 
44 |   set config_providers: [
45 |     {Distillery.Releases.Config.Providers.Elixir, ["${RELEASE_ROOT_DIR}/etc/config.exs"]}
46 |   ]
47 |   set overlays: [
48 |     {:copy, "rel/config/config.exs", "etc/config.exs"}
49 |   ]
50 | end
51 | 
52 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/rel/config/config.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # Set configuration for Phoenix endpoint
 4 | config :web, WebWeb.Endpoint,
 5 |   server: true,
 6 |   cache_static_manifest: "priv/static/cache_manifest.json",
 7 |   load_from_system_env: false,
 8 |   version: Application.spec(:web, :vsn),
 9 |   http: [port: 4000],
10 |   url: [host: "localhost", port: 4000],
11 |   root: ".",
12 |   secret_key_base: "u1QXlca4XEZKb1o3HL/aUlznI1qstCNAQ6yme/lFbFIs0Iqiq/annZ+Ty8JyUCDc"
13 | 
14 | 


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/rel/plugins/.gitignore:
--------------------------------------------------------------------------------
1 | *.*
2 | !*.exs
3 | !.gitignore


--------------------------------------------------------------------------------
/test/fixtures/umbrella_app/rel/vm.args:
--------------------------------------------------------------------------------
1 | -name umbrella
2 | 
3 | -setcookie <%= release.profile.cookie %>
4 | 


--------------------------------------------------------------------------------
/test/support/io_relay.ex:
--------------------------------------------------------------------------------
 1 | defmodule IORelay do
 2 |   @moduledoc false
 3 |   
 4 |   defstruct [:output, :device]
 5 | 
 6 |   def new(device) do
 7 |     %__MODULE__{output: "", device: device}
 8 |   end
 9 | 
10 |   defimpl Collectable do
11 |     def into(relay) do
12 |       collector = fn 
13 |         %{output: output, device: d} = relay, {:cont, content} -> 
14 |           IO.write(d, content)
15 |           %{relay | output: output <> content}
16 |         relay, :done ->
17 |           relay
18 |         _, :halt ->
19 |           :ok
20 |       end
21 |       {relay, collector}
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/test/support/purge_transform.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.SoftPurgeTransform do
 2 |   use Distillery.Releases.Appup.Transform
 3 | 
 4 |   def up(app, _v1, _v2, instructions, opts) do
 5 |     apply_transform(instructions, app, opts)
 6 |   end
 7 | 
 8 |   def down(app, _v1, _v2, instructions, opts) do
 9 |     apply_transform(instructions, app, opts)
10 |   end
11 | 
12 |   defp apply_transform(instructions, app, opts) do
13 |     default = Keyword.get(opts, :default, :soft_purge)
14 |     exclusions = Keyword.get(opts, :overrides, [])
15 |     apply_transform(instructions, [], app, default, exclusions)
16 |   end
17 | 
18 |   defp apply_transform([], acc, _app, _default, _exclusions), do: Enum.reverse(acc)
19 | 
20 |   defp apply_transform([i | ixs], acc, app, default, exclusions) do
21 |     purge_mode = Keyword.get(exclusions, app, default)
22 | 
23 |     cond do
24 |       elem(i, 0) == :update ->
25 |         new_i = handle_update(i, purge_mode)
26 |         apply_transform(ixs, [new_i | acc], app, default, exclusions)
27 | 
28 |       elem(i, 0) in [:load_module, :load] ->
29 |         new_i = handle_load(i, purge_mode)
30 |         apply_transform(ixs, [new_i | acc], app, default, exclusions)
31 | 
32 |       :else ->
33 |         apply_transform(ixs, [i | acc], app, default, exclusions)
34 |     end
35 |   end
36 | 
37 |   defp handle_update({:update, m}, purge), do: {:update, m, :soft, purge, purge, []}
38 |   defp handle_update({:update, _, :supervisor} = i, _purge), do: i
39 | 
40 |   defp handle_update({:update, m, dep_mods}, purge) when is_list(dep_mods),
41 |     do: {:update, m, :soft, purge, purge, dep_mods}
42 | 
43 |   defp handle_update({:update, m, c}, purge), do: {:update, m, c, purge, purge, []}
44 | 
45 |   defp handle_update({:update, m, c, dep_mods}, purge),
46 |     do: {:update, m, c, purge, purge, dep_mods}
47 | 
48 |   defp handle_update({:update, m, c, _, _, dep_mods}, purge),
49 |     do: {:update, m, c, purge, purge, dep_mods}
50 | 
51 |   defp handle_update({:update, m, to, c, _, _, dep_mods}, purge),
52 |     do: {:update, m, to, c, purge, purge, dep_mods}
53 | 
54 |   defp handle_update({:update, m, mt, to, c, _, _, dep_mods}, purge),
55 |     do: {:update, m, mt, to, c, purge, purge, dep_mods}
56 | 
57 |   defp handle_load({:load_module, m}, purge), do: {:load_module, m, purge, purge, []}
58 | 
59 |   defp handle_load({:load_module, m, dep_mods}, purge),
60 |     do: {:load_module, m, purge, purge, dep_mods}
61 | 
62 |   defp handle_load({:load_module, m, _, _, dep_mods}, purge),
63 |     do: {:load_module, m, purge, purge, dep_mods}
64 | 
65 |   defp handle_load({:load, {m, _, _}}, purge), do: {:load, {m, purge, purge}}
66 | end
67 | 


--------------------------------------------------------------------------------
/test/support/tasks.ex:
--------------------------------------------------------------------------------
 1 | defmodule Distillery.Test.Tasks do
 2 |   @moduledoc false
 3 | 
 4 |   def run(argv) do
 5 |     IO.inspect(argv)
 6 |   end
 7 | 
 8 |   def run(arg1, arg2) do
 9 |     IO.inspect(arg1: arg1, arg2: arg2)
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------