# Changelog for Yaque
## Version 0.2.0:
* Removed `async` from `Receiver::open` and `channel`. Instead of awaiting for
the the segment file to be created, the `Receiver` now atomically creates it if
it doesn't exist.
## Version 0.3.0 (yanked):
* `clear` is now `try_clear`. The method `clear` will be async and await the
queue to be accessible.
* `RecvGuard` will now *rollback on drop* (best effort). `RecvGuard::commit`
will have to be always invoked explicitly.
* You now may save the state of the queue explicitly in `Sender` and `Receiver`.
You can use this to backup the queue from time to time, which is useful if you
fear your program may abort.
## Version 0.3.1:
* Solved a bug in `RecvGuard::into_inner`: it was rolling back instead of
committing.
## Version 0.3.2 (yanked):
* Typo corrections.
* Small improvements to docs.
* Feature `recovery`: utilities for unlocking locks and to guess send metadata.
Guessing recv metadata is trickier and will be "coming soon".
* Performance improvements to the `Receiver`: buffer input + less lock contention.
This is _quite_ significant in terms of throughput.
## Version 0.3.3:
* Solved a bug in `recovery::unlock`: the file was not being parsed correctly.
* `recovery::unlock` now ignores missing files, as it should.
* Exposed `FileGuard`.
## Version 0.4.0:
* Renamed `Receiver::take_while` to `Receiver::take_until` because that is what
it does. Also, now the supplied closure must return a future. This allows for,
e.g., timers!
## Version 0.4.1:
* `Receiver::recv` is now really atomic in an async context. Therefore, if you
do not poll the future to completion, no changes will be made to the receiver
state.
## Version 0.4.3:
* Small improvements to docs.
* Unit tests will perform correctly after a previous run was interrupted by
CTRL+C.
* Created the `recovery::recover` function for a "full course" queue recover in
a single command.
## Version 0.5.0:
* `recv_timeout` and `recv_batch_timeout` to allow receiving with timeout.
* `recv_batch` is "atomic in an asynchronous context".
* Now, unlock works even if the process re-spawns with the same PID.
* Recovery of queue works with two modes: replay, which is the behavior of
`recovery::recover`, and "with loss", that discards the bottom segment entirely
(a bit extreme, but we will work on that). Use the
`recovery::recover_with_loss` for this option.
* Docs improvements.
* Refactored crate structure.
* Removed sender-side metadata (the `send_metadata` file). Now, the state of the
sender is always inferred as being the top of the top segment. Period. It
happens that having sender-side metadata was a liability (risk of overwriting data).
* Changed in-disk format! However, if you have no items greater than 67MB, you can
still benefit from compatibility. From now on, items are limited to ~67MB (a bit
tight, I know), but you get parity checking for an extra layer of safety. Expect
future releases to be completely incompatible with present format. Compatibility
is only supported within the same _minor_ version.
## Version 0.5.1:
* Corrected a bug on the `send_metadata` inference thingy. Now, all tests are passing.
## Version 0.6.0:
* Changed in-disk format again. This time, things are woefully incompatible. Don't use
a `<0.5.1` queue with `0.6.0`. You will fail miserably. The difference that breaks
compatibility is one extra parity bit flag in the item header. Before `0.6.0`, it was
used to ensure "legacy mode", where no parity checking took place. Now, it is a parity
bit all on itself. This leads to much more robust error detection (up to 2bits,
guaranteed, but you can get lucky with more!).
* Now you can control the sender more finely with `SenderBuilder`. This includes
choosing a segment size that fits your needs and choosing the "maximum size" for the
queue.
* And yes, now you can control maximum queue size so that `yaque` doesn't blow up your
hard drive. This means that some major API changes took place:
* `Sender::send` becomes `Sender::try_send` and returns a `TrySendError`. The same
thing happens to `Sender::send_batch`.
* A _new_ method called `Sender::send` is created that works like good old
`Sender::send`, except that it is async and `.await`s for the queue to shrink
below the maximum size. The same thing happens to `Sender::send_batch`.
* You can also just _try_ to receive items, without the need to `.await` anything. For
each fo the receiving methods `recv`, `recv_batch` and `recv_until` you now have the
try versions: `try_recv`, `try_recv_batch`, `try_recv_until`.
* Solved a bug regarding the rollback of batch transactions when crossing over a segment.
Older versions will do a complete mess out of this. The side effect: `commit` now returns
a `Result`, which has to be treated.
# Version 0.6.1:
* Introduced a new invariant: all items have to be read and used by the end of every
transaction. I could not verify if this invariant always holds. Anyway, there is an
assertion in the code to avoid the worse. If you find such a situation, please fill an
issue.
* Dropping the Receiver forced the `state` to be saved, not the `initial_state` (the
state at the beginning of the current transaction). Now, `Drop` calls `Receiver::save`
so that the behavior will be always consistent.
* We have a backup strategy for saving the queue! It involves no async stuff, so it will
only be triggered at the end of a transaction. The current criterion is: save at every
250 items read or every 350ms, whichever comes first. This should diminish greatly
the necessity for external control of the save mechanism.
* Created a `ReceiverBuilder` to allow people to customize the way the queue is saved.
This includes altering the above defaults or disabling queue saving altogether.
## Version 0.6.2:
* Created a `QueueIter` which allows to iterate through a queue as a list. The interface
is completely synchronous and has less overhead than just using the `Receiver`, besides
leading to clearer code.
* Documented some undocumented items.
* Upgraded dependencies and reduced the total number of them.
## Version 0.6.3:
* Changes to mirror the pre-releases of `notify`.
### Contributors:
* [@netguy204](https://github.com/netguy204)
## Version 0.6.4:
* Update dependencies and fix vulnerabilities (dependabot).
### Contributors:
* [@grant0417](https://github.com/grant0417)
## Version 0.6.6:
* Added `Receiver::recv_batch_up_to` and `Receiver::try_recv_batch_up_to` so that you can
fetch "up to `n`" elements from the queue or wait until one arrives.
* You can now send and receive empty messages.
* Fixed typos in the documentation.
### Contributors:
* [@mullr](https://github.com/mullr)