I’ve seen people talk bundling releases, and for which it basically sounds like the hot code-swapping works out-of-the-box, with no source code modification required.
But then I’ve also seen people talk about having to specify various callbacks in order to get them working.
Say I am using Presence and just don’t want to break connections on redeployment, is this possible without any source code modifications?
This is a really good question. I believe there are some special configuration settings to set, and some things that become impossible when doing hot code swapping, but I do not know the specifics.
One of the intricacies, I believe, is that care must be taken to transform the current state object stored in a GenServer to the new one, by writing a proper GenServer.code_change/3 implementation.
I would be very interested in an answer from someone who has used hot-code swapping themselves as well.
In general when a hot-swap is performed:
- The new code is loaded into the system, processes with old code keep running unless a another new version is loaded, then any processes with the old code are killed (and reloaded if in the supervision tree), the system supports 2 code versions per module at a time.
- A process that has its code reloaded gets a system message sent to it telling that, the OTP behaviours (like
GenServer) will handle that by calling your code_change function then swapping to the new code. If non-OTP you can handle that message by calling your loop function via a long call (
Module.myloop instead of just
myloop) to swap to the new code (while doing whatever conversions you want one way or another). The
Module.blah form always calls the new code of a module. The
blah form calls the local version of the code of a module (take in to account Elixir imports, those are long calls).
- And of course old versions can keep running too if they want, they will just be killed if they get more than one version out of date (of which a supervisor should recreate them if in a supervision tree).
Nice post. What’s the best source for information on hot-swapping your Elixir code?
Done via normal OTP release mechanics, so via exrm or distillery or whatever you use.
Some good docs of how erlang does it (which is how elixir does it) is at: http://learnyousomeerlang.com/relups
I’ve had some questions about this for some time, but haven’t had the time to test it myself. Everyone talks about changing the state of a genserver, so I fully understand that, but what happens if you add a new module to a supervisor, will it automatically be started? What if you remove a module from a supervisor, will it automatically be killed?
Edit: sorry for resurrecting this thread, I thought the last post was today, but it was actually exactly a year ago.
It’s in the OTP doc: http://erlang.org/doc/design_principles/appup_cookbook.html#id86501
Generally, these changes are not automatic, but you can tweak a release made via distillery to add them.