[Boost-users] Making an ASIO asynchronous operation from flock()

Subject: [Boost-users] Making an ASIO asynchronous operation from flock()
From: Cristian Morales Vega (cristian_at_[hidden])
Date: 2018-11-19 17:04:01

So I need to flock (http://man7.org/linux/man-pages/man2/flock.2.html)
something (pre-existing flock in other piece of software to
interoperate with) and I though: "I think I'm actually starting to
understand ASIO, let's make a proper ASIO asynchronous operation with
flock". Long story short, I now know better: I will never get ASIO.

So my main issues are with the background thread.
According to https://www.boost.org/doc/libs/develop/doc/html/boost_asio/overview/core/threads.html
"the threads ... must block all signals". OK, it makes sense, but...
- I can make pthread_sigmask() the first thing once the std::thread
starts executing. But, I can't really guarantee the thread will never
receive a signal, can I? There is a small amount of time between the
thread starting to be able to receive signals and pthread_sigmask()
doing its job. Modifying the signal mask before the background thread
is created (so also from the "not-background" thread) doesn't seem a
lot better.

- How do I cancel the asynchronous operation? flock() is blocking, not
a lot I can do to unblock it. I could send a signal to the background
thread, but... they must be blocked, so no. I can't join the thread
while it's blocked in flock(). So... should it be detached? I could
then maybe just destroy the std::thread, but I still need to call the
handler with boost::asio::error::operation_aborted...

So, my question: I'm making it more difficult than it is? There is
some pattern I should be following which makes all this simple?
See what I have below (sorry for the camel case)

-------------------------------------------------------------------------------
#include <boost/asio.hpp>
#include <boost/beast/core/bind_handler.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <fcntl.h>
#include <iostream>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <thread>

namespace asio = boost::asio;
using error_code = boost::system::error_code;
using system_error = boost::system::system_error;

class FLockablePosixDescriptor : public asio::posix::descriptor {
public:
  enum class FlockType : int { SHARED = LOCK_SH, EXCLUSIVE = LOCK_EX };

  using asio::posix::descriptor::descriptor;
  FLockablePosixDescriptor(FLockablePosixDescriptor &&) = default;
  FLockablePosixDescriptor &operator=(FLockablePosixDescriptor &&) = default;
  ~FLockablePosixDescriptor();

  template <typename FLockToken>
  BOOST_ASIO_INITFN_RESULT_TYPE(FLockToken, void(error_code))
  asyncFLock(FlockType type, FLockToken &&token);

  void cancel();
  void cancel(error_code &ec);

private:
  template <typename FLockHandler>
  void doFLock(int fd, FlockType type, FLockHandler &handler);

  asio::io_context mBackgroundContext{1};
  std::thread mThread;
};

FLockablePosixDescriptor::~FLockablePosixDescriptor() {
  mBackgroundContext.stop();
  mThread.join();
}

template <typename FLockToken>
BOOST_ASIO_INITFN_RESULT_TYPE(FLockToken, void(error_code))
FLockablePosixDescriptor::asyncFLock(FlockType type, FLockToken &&token) {
  asio::async_completion<FLockToken, void(error_code)> init(token);

  mBackgroundContext.post([this, fd = native_handle(), type,
                           handler = std::move(init.completion_handler),
                           work = asio::make_work_guard(get_executor())] {
    doFLock(fd, type, handler);
  });

  mThread = std::thread([this] { mBackgroundContext.run(); });

  return init.result.get();
}

template <typename FLockHandler>
void FLockablePosixDescriptor::doFLock(int fd, FlockType type,
                                       FLockHandler &handler) {
  error_code ec;

  if (flock(fd, static_cast<int>(type)) == -1) {
    ec = error_code(errno, boost::system::system_category());
  }

  asio::post(get_executor(), boost::beast::bind_handler(handler, ec));
}

void FLockablePosixDescriptor::cancel() {
  error_code ec;
  cancel(ec);
  if (ec) {
    throw system_error(ec, "cancel");
  }
}

void FLockablePosixDescriptor::cancel(error_code &ec) {
  // TODO: Cancel flock
  asio::posix::descriptor::cancel(ec);
}

int main() {
  boost::asio::io_context ioc;

  int fd = open("l", O_RDONLY);

  FLockablePosixDescriptor desc(ioc, fd);
  desc.asyncFLock(FLockablePosixDescriptor::FlockType::SHARED,
                  [](const error_code &ec) {
                    std::clog << "Done " << ec << std::endl;
                  });

  ioc.run();
}
-------------------------------------------------------------------------------