Libspinscale: Initial top-level SMO port to coroutine framework

We haven't ported everything. Just the top-level methods. We'll
dig in to the leaf stuff later. Surprisingly, this all went without
any real difficulties.

Runs like a charm on first try.

smocore/deviceManager/deviceReattacher.cpp

@@ -1,22 +1,20 @@
 #include <config.h>
+#include <chrono>
 #include <iostream>
 #include <functional>
 #include <componentThread.h>
-#include <spinscale/callback.h>
 #include <deviceManager/deviceReattacher.h>
 #include <deviceManager/deviceManager.h>
+#include <marionette/marionetteThread.h>
 
 namespace smo {
 namespace device {
 
-static void reattachmentCb(sscl::AsynchronousLoop& results)
-{
-	if (results.nTotal == 0) { return; }
+namespace {
 
-	std::cout << "DeviceReattacher: Successfully reattached "
-		<< results.nSucceeded << " of " << results.nTotal << " devices"
-		<< std::endl;
-}
+constexpr unsigned int reattachInFlightStaleThresholdMultiplier = 4;
+
+} // namespace
 
 DeviceReattacher::DeviceReattacher(
 	DeviceManager& parent, std::shared_ptr<sscl::ComponentThread> ioThread)
@@ -25,6 +23,22 @@ timer(ioThread->getIoService())
 {
 }
 
+mrntt::MrnttNonViralPostingInvoker DeviceReattacher::reattachKnownListCReq(
+	[[maybe_unused]] std::exception_ptr &exceptionPtr,
+	[[maybe_unused]] std::function<void()> callback)
+{
+	sscl::MultiOperationResultSet results = co_await
+		parent.attachAllUnattachedDevicesFromKnownListCReq();
+	if (results.nTotal > 0)
+	{
+		std::cout << "DeviceReattacher: Successfully reattached "
+			<< results.nSucceeded << " of " << results.nTotal
+			<< " devices" << std::endl;
+	}
+
+	co_return;
+}
+
 void DeviceReattacher::start()
 {
 	shouldContinue = true;
@@ -36,6 +50,14 @@ void DeviceReattacher::stop()
 	{
 		sscl::SpinLock::Guard lock(shouldContinueLock);
 		shouldContinue = false;
+		reattachOpInFlight = false;
+		/**	EXPLANATION:
+		 * Do not call reattachCReqInvoker.reset() here. Forcibly destroying
+		 * the invoker would tear down an in-flight reattach coroutine frame
+		 * mid-operation. During normal program teardown the optional (and
+		 * its invoker) are destroyed with the rest of the binary anyway; leave
+		 * a running reattach time to finish if shutdown races with it.
+		 */
 	}
 
 	timer.cancel();
@@ -56,6 +78,21 @@ void DeviceReattacher::scheduleNextTimeout()
 		std::bind(&DeviceReattacher::onTimeout, this, std::placeholders::_1));
 }
 
+void DeviceReattacher::holdReattachCReq()
+{
+	reattachOpInFlight = true;
+	lastReattachReqTimestamp = std::chrono::steady_clock::now();
+
+	reattachCReqInvoker.reset();
+	reattachCReqInvoker.emplace(reattachKnownListCReq(
+		reattachLifetimeExceptionPtr,
+		[this]()
+		{
+			sscl::SpinLock::Guard lock(shouldContinueLock);
+			reattachOpInFlight = false;
+		}));
+}
+
 void DeviceReattacher::onTimeout(const boost::system::error_code& error)
 {
 	// Timer was cancelled, which is expected when stopping
@@ -75,9 +112,32 @@ void DeviceReattacher::onTimeout(const boost::system::error_code& error)
 		return;
 	}
 
+	const auto staleThreshold = std::chrono::milliseconds(
+		reattachInFlightStaleThresholdMultiplier
+			* CONFIG_MRNTT_DEVMGR_REATTACHER_PERIOD_MS);
+
 	// Attempt to reattach all unattached devices from the known list
-	parent.attachAllUnattachedDevicesFromKnownListReq(
-		{ nullptr, reattachmentCb});
+	if (!reattachOpInFlight)
+	{
+		holdReattachCReq();
+	}
+	else
+	{
+		const auto elapsedSinceLastReattachReq =
+			std::chrono::steady_clock::now() - lastReattachReqTimestamp;
+
+		if (elapsedSinceLastReattachReq >= staleThreshold)
+		{
+			std::cerr << "DeviceReattacher: Reattach op still in flight after "
+				<< std::chrono::duration_cast<std::chrono::milliseconds>(
+					elapsedSinceLastReattachReq).count()
+				<< "ms (threshold "
+				<< staleThreshold.count()
+				<< "ms); forcing a new reattach request."
+				<< std::endl;
+			holdReattachCReq();
+		}
+	}
 
 	// Schedule the next timeout
 	scheduleNextTimeout();