No changes yet.
RabbitMQ Java client dependency has been updated to 5.14.x.
RabbitMQ Java client dependency has been updated to 5.13.x.
Contributed by Glen Mailer.
GitHub issue: #107
langohr.http/close-all-connections is a new function that closes all client
connections on the target nodes. This is primarily useful in integration tests
and certain monitoring scenarios.
Correct a typo in langohr.http/get-node that made the "short
arity" version fail.
GitHub issue: #101.
langohr.core/connect now support hostname verification via the new :verify-hostname
option (a boolean). Hostname verification is one part of TLS peer verification
supported by RabbitMQ Java client and now Langohr.
GitHub issue: #100.
RabbitMQ Java client dependency has been updated to 5.9.x.
Langohr now depends on Clojure 1.10.0 by default.
RabbitMQ Java client dependency has been updated to 5.5.x.
This release includes breaking public API changes.
RabbitMQ Java client dependency has been updated to 5.x.
RabbitMQ Java client 5.x requires JDK 8. It's a good chance
to drop support for older JDKs in Langohr. Langohr 4.x continues
to use a JDK 6 and 7-compatible version of the Java client.
RabbitMQ Java client 5.0 removed a long deprecated queueing consumer
abstraction that used an internal j.u.c queue for deliveries and acted as
an iterator. That consumer implementation never supported automatic connection
recovery and isn't necessary with modern consumer operation dispatch pool.
Langohr follows suit and removes the following functions based on the QueueingConsumer:
langohr.basic/blocking-subscribelangohr.consumers/create-queueinglangohr.consumers/deliveries-seq
langohr.consumers/deliveries-seq may be reintroduced in the future if a reasonable
imlementation for it comes to mind/is contributed.
clj-http dependency has been updated to 3.8.x.
Deleted a redundant type hint.
Contributed by Michal Masztalski.
RabbitMQ Java client dependency has been updated to 4.4.1.
clj-http dependency has been updated to 3.7.0.
Cheshire dependency has been updated to 5.8.0.
clj-http dependency has been updated to 3.6.0.
Cheshire dependency has been updated to 5.7.1.
RabbitMQ Java client dependency has been updated to 4.0.0.
clj-http dependency has been updated to 3.5.0.
RabbitMQ Java client dependency has been updated to 3.6.6.
clj-http dependency has been updated to 3.4.1.
Cheshire dependency has been updated to 5.6.3.
:connection-name is a new connection option supported by Langohr 3.6.0 and RabbitMQ
server 3.6.2 or later. It can be used to set a client- or application-specific
connection name that will be displayed in the management UI.
RabbitMQ Java client dependency has been updated to 3.6.2.
clj-http dependency has been updated to 3.1.0.
Cheshire dependency has been updated to 5.6.1.
GH issue: #79.
RabbitMQ Java client dependency has been updated to 3.6.0.
RabbitMQ Java client dependency has been updated to 3.5.7.
RabbitMQ Java client dependency has been updated to 3.5.6.
Langohr now uses Java client's forgiving exception handler by default. This means unhandled consumer exceptions won't result in channel closure.
RabbitMQ Java client dependency has been updated to 3.5.4.
clj-http dependency has been updated to 2.0.0.
This version of clj-http bumps Apache HTTP client version to 4.5. If this is undesirable for your project, you can exclude Langohr's dependency on clj-http and use another version.
See Langohr's project.clj (the cljhttp076 profile).
Cheshire dependency has been updated to 5.5.0.
Langohr now converts :authentication-mechanism option to a SASL
mechanism. Two values are supported:
"PLAIN""EXTERNAL"
Contributed by Tap.
RabbitMQ Java client dependency has been updated to 3.5.2.
clj-http dependency has been updated to 1.1.1.
RabbitMQ Java client dependency has been updated to 3.4.4.
It includes an important binding recovery bug fix.
clj-http dependency has been updated to 1.0.1.
Cheshire dependency has been updated to 5.4.0.
langohr.consumers/blocking-subscribe no longer fails with a function arity
exception.
GH issue: #65.
Functions that take options now require a proper Clojure map instead of pseudo keyword arguments:
;; in Langohr 2.x
(lq/declare ch q :durable true)
(lhcons/subscribe ch q (fn [_ _ _])
:consumer-tag ctag :handle-cancel-ok (fn [_]))
(lb/publish ch "" q "a message" :mandatory true)
;; in Langohr 3.x
(lq/declare ch q {:durable true})
(lhcons/subscribe ch q (fn [_ _ _])
{:consumer-tag ctag :handle-cancel-ok (fn [_])})
(lb/publish ch "" q "a message" {:mandatory true})Langohr test suite now passes on JDK 8 (previously there was 1 failure in recovery test).
GH issue: #54.
Langohr no longer implements automatic connection recovery of its own. The feature is still there and there should be no behaviour changes but the functionality has now been pushed "upstream" in the Java client, so Langohr now relies on it to do all the work.
There is two public API changes:
-
com.novemberain.langohr.Recoverableis gone,langohr.core/on-recoverynow usescom.rabbitmq.client.Recoverableinstead in its signature. -
Server-named queues will change after recovery. Use
langohr.core/on-queue-recoveryto register a listener for queue name change.
GH issue: #58.
RabbitMQ Java client dependency has been updated to 3.4.2.
langohr.core/exception-handler is a function that customizes
default exception handler RabbitMQ Java client uses:
(require '[langohr.core :as rmq])
(let [(rmq/exception-handler :handle-consumer-exception-fn (fn [ch ex consumer
consumer-tag method-name]
))]
)Valid keys are:
:handle-connection-exception-fn:handle-return-listener-exception-fn:handle-flow-listener-exception-fn:handle-confirm-listener-exception-fn:handle-blocked-listener-exception-fn:handle-consumer-exception-fn:handle-connection-recovery-exception-fn:handle-channel-recovery-exception-fn:handle-topology-recovery-exception-fn
GH issue: #47.
Clojure 1.7-specific compilation issues and warnings were eliminated.
clj-http dependency has been updated to 1.0.0.
clojurewerkz/support dependency has been updated to 1.1.0.
langohr.core/version was removed.
langohr.core/connect now supports :hosts as well as :host.
The hosts provided will be iterated over, the first reachable host
will be used.
Example:
(require '[langohr.core :as rmq])
(rmq/connect {:hosts #{"192.168.1.2" "192.168.1.3"}})
;; uses port 5688 for both hosts
(rmq/connect {:hosts #{"192.168.1.2" "192.168.1.3"} :port 5688})
;; uses multiple host/port pairs
(rmq/connect {:hosts #{["192.168.1.2" 5688] ["192.168.1.3" 5689]}})All IOException subclasses thrown during connection recovery attempts will now be retried.
Contributed by Paul Bellamy (Xively).
RabbitMQ Java client dependency has been updated to 3.3.1.
Most HTTP API client functions now have an additional optional arguments,
which is a map of options passed to clj-http functions. This lets you fine
tune certain HTTP requests as needed.
In addition, langohr.http/connect! now accepts one more argument which serves
as default HTTP client options merged with the options provided per langohr.http
function call:
(require '[langohr.http :as hc])
;; non-20x/30x statuses will now throw exceptions
(hc/connect! "http://127.0.0.1:15673" "guest" "guest" {:throw-exceptions true})
;; disable throwing exceptions for an individual operation,
;; because 404 is an expected HTTP response in this case
(hc/vhost-exists? "myapp-production" {:throw-exceptions false})
;= false
;; disabling peer verification for HTTPS requests
(hc/connect! "http://127.0.0.1:15673" "guest" "guest" {:insecure? true})It is now possible to customize a java.util.concurrent.ThreadFactory
used by Langohr connections. The factory will be used to instantiate
all threads created by the client under the hood.
The primary use case for this is running on Google App Engine which prohibits direct thread instantiation and requires apps to use thread manager (or thread factory) from GAE SDK instead.
To provide a custom thread factory, pass it as :thread-factory to
langohr.core/connect. To reify a thread factory with a Clojure function,
use langohr.core/thread-factory-from:
(require '[langohr.core :as lc])
(let [tf (lc/thread-factory-from
(fn [^Runnable r]
(Thread. r)))]
(lc/connect {:thread-factory tf}))Langohr now uses com.rabbitmq.client.TopologyRecoveryException instead of reinventing its own exception to indicate topology recovery failure.
A few RabbitMQ Java client interface compatibility issues are resolved.
langohr.channel/flow and langohr.channel/flow? were removed.
Client-side flow control has been deprecated for a while and was removed
in RabbitMQ Java client 3.3.0.
RabbitMQ Java client dependency has been updated to 3.3.0.
Langohr now depends on org.clojure/clojure version 1.6.0. It is
still compatible with Clojure 1.4 and if your project.clj depends on
a different version, it will be used, but 1.6 is the default now.
We encourage all users to upgrade to 1.6, it is a drop-in replacement for the majority of projects out there.
langohr.http/protocol-ports is a new function that returns
a map of protocol names to protocol ports. The protocols
are listed with langohr.http/list-enabled-protocols.
langohr.http/list-enabled-protocols is a new function that lists
the protocols a RabbitMQ installation supports, e.g. "amqp" or "mqtt".
Note that this currently does not include WebSTOMP (due to certain technical decisions
in RabbitMQ Web STOMP plugin).
langohr.http/list-connections-from and langohr.http/close-connections-from
are two new functions that list and close connections for a given username,
respectively:
(require '[langohr.http :as hc])
(hc/list-connections-from "guest")
;= a list of connections with username "guest"
;; closes all connections from "guest"
(hc/close-connections-from "guest")clj-http dependency has been updated to 0.9.0.
langohr.http/declare-user was renamed to langohr.http/set-user.
langohr.http/declare-policy was renamed to langohr.http/set-policy.
langohr.http/declare-permissions was renamed to langohr.http/set-permissions.
langohr.http/declare-user was renamed to langohr.http/add-user.
langohr.http/vhost-exists? is a new function that returns true if provided
vhost exists:
(require '[langohr.http :as hc])
(hc/vhost-exists? "killer-app-dev")langohr.http/user-exists? is a new function that returns true if provided
user exists:
(require '[langohr.http :as hc])
(hc/user-exists? "monitoring")RabbitMQ Java client dependency has been updated to 3.2.4.
clj-http dependency has been updated to 0.7.9.
:automatically-recover-topology default is now true, as listed in
documentation.
Contributed by Ilya Ivanov.
langohr.core/automatically-recover? is deprecated
Use langohr.core/automatic-recovery-enabled? instead.
langohr.core/automatic-recovery-enabled? and langohr.core/automatic-topology-recovery-enabled?
are new predicate functions that return true if automatic connection and topology recovery,
respectively, is enabled for the provided connection.
Topology recovery now fails quickly, raising
com.novemberain.langohr.recovery.TopologyRecoveryException which
carries the original (cause) exception.
Previously if recovery of an entity failed, other entities were still recovered. Now topology recovery fails on the first exception, making issues more visible.
Automatic recovery options now respect both false and nil values.
Automatic topology recovery no longer kicks in when it is disabled.
Automatic topology recovery now tracks entities (exchanges, queues, bindings, and consumers) per connection. This makes it possible to, say, declare an exchange on one channel, delete it on another channel and not have it reappear.
Suggested by Jonathan Halterman.
RabbitMQ Java client dependency has been updated to 3.2.2.
clj-http dependency has been updated to 0.7.8.
Cheshire dependency has been updated to 5.3.1.
Channel recovery now involves recovery of publisher confirms and transaction modes.
Langohr now correctly removes bindings from the list of
bindings to recover when a binding is removed using queue.unbind
or exchange.unbind.
Connection recovery now supports entity recovery. Queues, exchanges,
bindings and consumers can be recovered automatically after channel
recovery. This feature is enabled by default and can be disabled
by setting the :automatically-recover-topology option to false.
:requested-channel-max is a new option accepted by
langohr.core/connect that configures how many channels
this connection may have. The limit is enforced on the client
side. 0 means "no limit" and is the default.
Contributed by Glophindale.
langohr.queue/empty? is a new function that returns true if provided
queue is empty (has 0 messages ready):
(require '[langohr.queue :as lq])
(lq/empty? ch "a.queue")
;= truelangohr.core/add-shutdown-listener is a helper function that
reifies and registers a shutdown signal listener on a connection.
langohr.core/add-blocked-listener is a helper function that
reifies and registers a connection.blocked and connection.unblocked
listener on a connection.
Langohr will now make sure to handle network I/O-related exceptions during recovery and reconnect every N seconds.
RabbitMQ Java client dependency has been updated to 3.2.1.
RabbitMQ Java client dependency has been updated to 3.2.0.
Connections will only be recovered if shutdown was not application-initiated.
Contributed by Stephen Dienst.
Langohr now depends on ClojureWerkz Support 0.20.0.
langohr.conversion/BytePayload and langohr.conversion/to-bytes
are replaced by clojurewerkz.support.bytes/ByteSource and
clojurewerkz.support.bytes/to-byte-array, respectively.
Automatic recovery of channels that are created without an explicit number now works correctly.
Contributed by Joe Freeman.
clj-http dependency has been updated to 0.7.6.
Langohr requires Clojure 1.4+ as of this version.
langohr.confirm/wait-for-confirms is a new function that
waits until all outstanding confirms for messages
published on the given channel arrive. It optionally
takes a timeout:
(langohr.confirm/wait-for-confirms ch)
;; wait up to 200 milliseconds
(langohr.confirm/wait-for-confirms ch 200)Automatic recovery now can be enabled without causing an exception.
They can be used to re-declare necessary entities using langohr.core/on-recovery:
(langohr.core/on-recovery conn (fn [conn] (comment ...)))
(langohr.core/on-recovery ch (fn [ch] (comment ...)))Unlike OO clients that represent queues and exchanges as objects, Langohr cannot be more aggressive about redeclaring entities during connection recovery.
The function creates a QueueingConsumer instance and is very similar
to langohr.consumers/create-default in purpose.
Sometimes combining a queueing consumer with
langohr.consumers/deliveries-seq is the best way to express a
problem.
langoh.consumers/deliveries-seq is a function that turns a QueueingConsumer instance
into a lazy sequence of deliveries.
Connection recovery after network failure will now respect the :executor
option.
Langohr's implementation of connection and channel now implements RabbitMQ Java client's interfaces for connection and channel.
langohr.http now provides more complete coverage of the RabbitMQ HTTP API.
Contributed by Steffen Dienst.
The documentation says to use function handler keys ending in
"-fn", but this code currently only recognizes the old form. This
commit ensures that all keys that are used within
langohr.consumers/subscribe can be used as a parameter.
Contributed by Steffen Dienst.
langohr.shutdown/soft-error? is now correctly named.
Contributed by Ralf Schmitt.
langohr.core/connect-to-first-available is removed. A better failover functionality
will be available in future versions.
RabbitMQ Java client dependency has been updated to 3.1.3.
clj-http dependency has been updated to 0.7.4.
Cheshire dependency has been updated to 5.2.0.
In its early days, Langohr has been using QueueingConsumer for langohr.queue/subscribe.
It was later replaced by a DefaultConsumer implementation.
The key difference between the two is that
QueueingConsumerblocks the caller- with
QueueingConsumer, deliveries are typically processed in the same thread
This implementation has pros and cons. As such, an implementation on top of
QueueingConsumer is back with langohr.consumers/blocking-subscribe which is
identical to langohr.consumers/subscribe in the signature but blocks the caller.
In addition, langohr.consumers/ack-unless-exception is a new convenience function
that takes a delivery handler fn and will return a new function
that explicitly acks deliveries unless an exception was raised by the original handler:
(require '[langohr.consumers :as lc])
(require '[langohr.basic :as lb])
(let [f (fn [metadata payload]
(comment "Message delivery handler"))
f' (lc/ack-unless-exception f)]
(lb/consume ch q (lc/create-default :handle-delivery-fn f'))Contributed by Ian Eure.
Several new functions in langohr.shutdown aid with shutdown signals:
langohr.shutdown/initiated-by-application?langohr.shutdown/initiated-by-broker?langohr.shutdown/reason-oflangohr.shutdown/channel-oflangohr.shutdown/connection-of
Langohr now depends on org.clojure/clojure version 1.5.0. It is
still compatible with Clojure 1.3 and if your project.clj depends on
a different version, it will be used, but 1.5 is the default now.
We encourage all users to upgrade to 1.5, it is a drop-in replacement for the majority of projects out there.
1.0.0-beta13 has BREAKING CHANGES:
The options langohr.consumers/subscribe takes now have consistent naming:
:handle-consume-okbecomes:handle-consume-ok-fn:handle-cancelbecomes:handle-cancel-fn:handle-cancel-okbecomes:handle-cancel-ok-fn:handle-shutdown-signal-okbecomes:handle-shutdown-signal-ok-fn:handle-recover-okbecomes:handle-recover-ok-fn:handle-delivery-fndoes not change
This makes handler argument names consistent across the board.
Previous options (:handle-cancel, etc) are still supported
for backwards compatibility but will eventually be removed.
Previously functions such as langohr.queue/declare returned the underlying
RabbitMQ Java client responses. In case a piece of information from the
response was needed (e.g. to get the queue name that was generated by
RabbitMQ), the only way to obtain it was via the Java interop.
This means developers had to learn about how the Java client works. Such responses are also needlessly unconvenient when inspecting them in the REPL.
Langohr 1.0.0-beta12 makes this much better by returning a data structure
that behaves like a regular immutable Clojure map but also provides the same
Java interoperability methods for backwards compatibility.
For example, langohr.queue/declare now returns a value that is a map
but also provides the same .getQueue method you previously had to use.
Since the responses implement all the Clojure map interfaces, it is possible to use destructuring on them:
(require '[langohr.core :as lhc])
(require '[langohr.queue :as lhq])
(let [conn (lhc/connect)
channel (lhc/create-channel conn)
{:keys [queue] :as declare-ok} (lhq/declare channel "" :exclusive true)]
(println "Response: " declare-ok)
(println (format "Declared a queue named %s" queue)))will output
Response: {:queue amq.gen-G9bmz19UjHLBjyxhanOG3Q, :consumer-count 0, :message_count 0, :consumer_count 0, :message-count 0}
Declared a queue named amq.gen-G9bmz19UjHLBjyxhanOG3Q
langohr.confirm/add-listener now returns the channel instead of the listener. This way
it is more useful with the threading macro (->) that threads channels (a much more
common use case).
langohr.exchage/unbind was missing in earlier releases and now added.
langohr.core/closed? is a new function that complements langohr.core/open?.
langohr.queue/declare-server-named is a new convenience function
that declares a server-named queue and returns the name RabbitMQ
generated:
(require '[langohr.core :as lhc])
(require '[langohr.queue :as lhq])
(let [conn (lhc/connect)
channel (lhc/create-channel conn)
queue (lhq/declare-server-named channel)]
(println (format "Declared a queue named %s" queue))Langohr will now correct the port to TLS/SSL if provided :port is
5672 (default non-TLS port) and :ssl is set to true.
Langohr 1.0.0-beta11 features initial bits of RabbitMQ HTTP API client
under langohr.http.
Langohr will now automatically enable TLS/SSL if provided :port is
5671.
RabbitMQ Java Client has been upgraded to version 3.0.2.
langohr.exchange/declare-passive is a new function that performs passive
exchange declaration (checks if an exchange exists).
An example to demonstrate:
(require '[langohr.channel :as lch])
(require '[langohr.exchange :as le])
(let [ch (lch/open conn)]
(le/declare-passive ch "an.exchange"))If the exchange does exist, the function has no effect. If not,
an exception (com.rabbitmq.client.ShutdownSignalException, java.io.IOException) will be thrown.
langohr.basic/reject now correctly uses basic.reject AMQP method
and not basic.ack.
Contributed by @natedev.
1.0.0-beta9 has BREAKING CHANGES:
Langohr no longer instantiates a string from the message body before passing it to return listeners. The body will be passed as is, as an array of bytes.
1.0.0-beta8 has BREAKING CHANGES:
langohr.basic/get now returns a pair of [metadata payload] to be consistent with what
delivery handler functions accept:
(require '[langohr.basic :as lhb])
(let [[metadata payload] (lhb/get channel queue)]
(println metadata)
(println (String. ^bytes payload)))1.0.0-beta7 has BREAKING CHANGES:
The options langohr.consumers/create-default takes now have consistent naming:
:consume-ok-fnbecomes:handle-consume-ok-fn:cancel-fnbecomes:handle-cancel-fn:cancel-ok-fnbecomes:handle-cancel-ok-fn:shutdown-signal-ok-fnbecomes:handle-shutdown-signal-ok-fn:recover-ok-fnbecomes:handle-recover-ok-fn:handle-delivery-fndoes not change
This makes handler argument names consistent across the board.
1.0.0-beta6 has BREAKING CHANGES:
langohr.consumers/create-default's :handle-delivery-fn signature is now consistent with
that of langohr.basic/subscribe:
(fn [^Channel ch metadata ^bytes payload]
)This makes delivery handler signatures consistent across the board.
langohr.core/connect now supports several more options:
:ssl(true or false): when true, Langohr will use the default SSL protocol (SSLv3) and the default (trusting) trust manager:ssl-context(javax.net.ssl.SSLContext): SSL context to use to create connection factory:sasl-config(com.rabbitmq.client.SaslConfig): use if you need to use a custom SASL config:socket-factory(javax.net.SocketFactory): use if you need to use a custom socket factory
Langohr now provides its capabilities to the broker so it's possible to tell the difference between Langohr and the RabbitMQ Java client in the RabbitMQ Management UI connection information.
langohr.core/capabilities-of is a new function that returns broker capabilities as an immutable map,
e.g.
{:exchange_exchange_bindings true
:consumer_cancel_notify true
:basic.nack true
:publisher_confirms true}Langohr now depends on org.clojure/clojure version 1.4.0. It is still compatible with Clojure 1.3 and if your project.clj depends
on 1.3, it will be used, but 1.4 is the default now.
We encourage all users to upgrade to 1.4, it is a drop-in replacement for the majority of projects out there.
langohr.basic/publish no longer assumes the payload is always a string. It can be anything the langohr.conversion/BytePayload
protocol is implemented for, by default byte arrays and strings.
langohr.queue/declare now uses default value for the :exclusive parameter as false. The reason for
this is that exclusive queues are deleted when connection that created them is closed. This caused
confusion w.r.t. non-auto-deleted queues being deleted in such cases.
langohr.core/settings-from is a new public API function that parses AMQP and AMQPS connection URIs
and returns an immutable map of individual arguments. URI parsing is now delegated to the Java client
for consistency.
RabbitMQ Java Client has been upgraded to version 2.8.6.
Previously message handlers registered via langohr.consumers/subscribe had the following
signature:
(fn [^QueueingConsumer$Delivery delivery ^AMQP$BasicProperties properties payload] ...)starting with beta2, it has changed to be more Clojure friendly
(fn [^Channel ch metadata payload] ...)All message metadata (both envelope and message properties) are now passed in as a single Clojure map that you can use destructuring on:
(fn [^Channel ch {:keys [type content-type message-id correlation-id] :as metadata} payload] ...)In addition, in explicit acknowledgement mode, ack-ing and nack-ing messages got easier because consumer channel is now passed in.
It is important to remember that sharing channels between threads that publish messages is dangerous and should be avoided. Ack-ing, nack-ing and consuming messages with shared channels is usually acceptable.
RabbitMQ Java Client which Langohr is based on has been upgraded to version 2.8.1.
Langohr now uses Leiningen 2.