Lightweight containers for Clojure namespaces. Atomic reloading and disaster recovery included.
The Two-And-A-Half-Minute Pitch
Got a minute or two? Check out the bubbly lightning talk.
High-level usage overview
Create a new bubble by calling
The returned bubble is empty.
┌────────────────────┐ │ │ │ │ │ bubble │ └────────────────────┘
In order to fill it with your namespaces use
The function takes two obligatory arguments: the bubble itself and a collection
of sources of namespaces you want to load.
The code which you pass is compiled into a container in the bubble.
┌────────────────────┐ │ ┌───────┐ │ │ │ns1 ns2│ │ │ └───────┘ │ │ bubble │ └────────────────────┘
Instead of calling
bubble.core/blow directly you can use the
plugin available in the
It allows you to remotely inject code into a bubble over nREPL.
You cannot call code loaded in a bubble directly;
in order to access vars inside you have to use
Expected arguments are a bubble and a qualified symbol of the var you want to
Think of it as a lens through which you can look into a bubble.
┌────────────────────┐ │ ┌───────┐ │ through → ns1 ns2│ │ │ └───────┘ │ │ bubble │ └────────────────────┘
Code in a bubble can be safely reloaded.
In order to guarantee that the new version will not interfere with existing code
the previously built container remains unaltered.
bubble.core/blow puts new code in a separate container.
┌────────────────────┐ │ ┌───────┐┌───────┐ │ through → ns1 ns2││ns1 ns2│ │ │ └───────┘└───────┘ │ │ bubble │ └────────────────────┘
In absence of errors
bubble.core/through invoked on the bubble will return
vars from the new container.
The old container will be disposed of.
┌────────────────────┐ │ ┌───────┐ │ │ │ns1 ns2 ← through │ └───────┘ │ │ bubble │ └────────────────────┘
On the other hand, any errors which happen during reloading will cause the newly build container to be deleted. The old one will remain unchanged.
bubble.core/blow accepts two optional named arguments:
:before is invoked once the new container is successfully loaded but before
the old one is replaced.
It can be used to perform arbitrary actions in newly compiled namespaces, e.g.
opening listening sockets, initialising connections to remote services or
running basic sanity checks.
Any exception thrown from
:before will cancel the reload, remove new code and
leave the bubble in the state from before invocation of
:after is called once the container is being removed after next successful
bubble.core/blow on this bubble.
It is supposed to clean up everything what the
:before function had initialised.
Exceptions thrown from this function are ignored.
:after receive a single argument: an unary function through
which vars in newly loaded and currently unloaded namespaces respectively can be
Take a look inside the
examples directory to see how Bubble can be used in
practice in order to achieve pauseless and atomic reloading of Clojure sources.
Copyright (c) 2014 Jan Stępień Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.