Skip to content
Merged
96 changes: 57 additions & 39 deletions cpp/shared/bridge/HybridSMB.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@

#include <NitroModules/Promise.hpp>
#include <stdexcept>
#include <thread>
#include <utility>

#include "../connection/PoolTypes.hpp"
Expand All @@ -29,6 +30,7 @@

namespace margelo::nitro::smb {

using react_native_smb::SlotReservation;
using react_native_smb::SmbTask;
using DomainTaskState = react_native_smb::SmbTaskState;
using DomainPoolSlotInfo = react_native_smb::PoolSlotInfo;
Expand All @@ -44,14 +46,13 @@ void HybridSMB::releaseTaskRun(const std::shared_ptr<TaskRunState>& state) {
state->cv.notify_all();
}

template <typename OpT>
std::shared_ptr<SmbTask> HybridSMB::startTask(const std::string& taskId, std::unique_ptr<OpT> seedOp, ExecutionLane lane) {
std::shared_ptr<SmbTask> HybridSMB::startTask(const std::string& taskId, std::unique_ptr<react_native_smb::OperatorBase> op) {
std::lock_guard<std::mutex> shutdownLock(shutdownMutex_);
if (disposed_.load(std::memory_order_acquire)) {
SmbException::raise(SmbErrorCode::NotConnected, "SMB client has been destroyed");
}

auto task = std::make_shared<SmbTask>(taskId, std::move(seedOp), pool_);
auto task = std::make_shared<SmbTask>(taskId, std::move(op), pool_);
if (observer_) {
observer_->track(task);
}
Expand All @@ -65,36 +66,53 @@ std::shared_ptr<SmbTask> HybridSMB::startTask(const std::string& taskId, std::un
std::lock_guard<std::mutex> lock(taskRuns->mutex);
++taskRuns->active;
}

auto* self = this;
auto runBody = [self, task, taskId, taskRuns] {
struct RunCompletionGuard {
std::shared_ptr<TaskRunState> state;
~RunCompletionGuard() { HybridSMB::releaseTaskRun(state); }
} guard{taskRuns};
task->start();
// Runs once per task, after it settles on any path.
auto finish = [self = this, taskId, taskRuns] {
self->forgetTask(taskId);
releaseTaskRun(taskRuns);
};

try {
if (lane == ExecutionLane::Lifecycle) {
lifecycleExecutor_.post(std::move(runBody));
} else {
(void)Promise<void>::async(std::move(runBody));
if (!task->prepare()) {
finish();
return task;
}

const auto mode = task->acquireMode();
if (!mode) {
try {
lifecycleExecutor_.post([task, finish] {
task->run(std::nullopt);
finish();
});
} catch (...) {
finish();
throw;
}
} catch (...) {
releaseTaskRun(taskRuns);
forgetTask(taskId);
throw;
return task;
}

task->markPending();
pool_->requestContext(*mode, task->getKind(), taskId,
{[task, finish](SlotReservation reservation) {
try {
std::thread([task, finish, reservation = std::move(reservation)]() mutable {
task->run(std::move(reservation));
finish();
}).detach();
} catch (const std::exception& e) {
task->reject(static_cast<int>(SmbErrorCode::Unknown), e.what());
finish();
}
},
[task, finish](int code, const std::string& message) {
task->reject(code, message);
finish();
}});
return task;
}

template <typename OpT>
std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::createTask(const std::string& taskId, std::unique_ptr<OpT> seedOp,
ExecutionLane lane) {
return std::make_shared<HybridSmbTask>(startTask(taskId, std::move(seedOp), lane));
std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::createTask(const std::string& taskId, std::unique_ptr<react_native_smb::OperatorBase> op) {
return std::make_shared<HybridSmbTask>(startTask(taskId, std::move(op)));
}

HybridSMB::HybridSMB() : HybridObject(TAG) {
Expand Down Expand Up @@ -169,23 +187,23 @@ bool HybridSMB::isInitialized() { return pool_->isInitialized(); }

// --- connection ---
std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::initialize(const std::string& taskId, const std::string& url, const SmbCredentials& credentials) {
return createTask<react_native_smb::InitializeOperator>(taskId, std::make_unique<react_native_smb::InitializeOperator>(url, fromBridge(credentials)), ExecutionLane::Lifecycle);
return createTask(taskId, std::make_unique<react_native_smb::InitializeOperator>(url, fromBridge(credentials)));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::connect(const std::string& taskId, const std::string& url, const SmbCredentials& credentials) {
return createTask<react_native_smb::ConnectOperator>(taskId, std::make_unique<react_native_smb::ConnectOperator>(url, fromBridge(credentials)), ExecutionLane::Lifecycle);
return createTask(taskId, std::make_unique<react_native_smb::ConnectOperator>(url, fromBridge(credentials)));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::disconnect(const std::string& taskId) {
return createTask<react_native_smb::DisconnectOperator>(taskId, std::make_unique<react_native_smb::DisconnectOperator>(), ExecutionLane::Lifecycle);
return createTask(taskId, std::make_unique<react_native_smb::DisconnectOperator>());
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::listShares(const std::string& taskId) {
return createTask<react_native_smb::ListSharesOperator>(taskId, std::make_unique<react_native_smb::ListSharesOperator>());
return createTask(taskId, std::make_unique<react_native_smb::ListSharesOperator>());
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::connectShare(const std::string& taskId, const std::string& share) {
return createTask<react_native_smb::ConnectShareOperator>(taskId, std::make_unique<react_native_smb::ConnectShareOperator>(share), ExecutionLane::Lifecycle);
return createTask(taskId, std::make_unique<react_native_smb::ConnectShareOperator>(share));
}

// --- listing ---
Expand All @@ -195,45 +213,45 @@ std::shared_ptr<HybridNativeSmbListTaskSpec> HybridSMB::listDirectory(const std:
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::getPathInfo(const std::string& taskId, const std::string& path) {
return createTask<react_native_smb::GetPathInfoOperator>(taskId, std::make_unique<react_native_smb::GetPathInfoOperator>(path));
return createTask(taskId, std::make_unique<react_native_smb::GetPathInfoOperator>(path));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::getSecurityDescriptor(const std::string& taskId, const std::string& path) {
return createTask<react_native_smb::GetSecurityDescriptorOperator>(taskId, std::make_unique<react_native_smb::GetSecurityDescriptorOperator>(path));
return createTask(taskId, std::make_unique<react_native_smb::GetSecurityDescriptorOperator>(path));
}

// --- transfer ---
std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::downloadFile(const std::string& taskId, const std::string& remotePath, const std::string& localPath) {
return createTask<react_native_smb::DownloadFileOperator>(taskId, std::make_unique<react_native_smb::DownloadFileOperator>(remotePath, localPath));
return createTask(taskId, std::make_unique<react_native_smb::DownloadFileOperator>(remotePath, localPath));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::uploadFile(const std::string& taskId, const std::string& localPath, const std::string& remotePath) {
return createTask<react_native_smb::UploadFileOperator>(taskId, std::make_unique<react_native_smb::UploadFileOperator>(localPath, remotePath));
return createTask(taskId, std::make_unique<react_native_smb::UploadFileOperator>(localPath, remotePath));
}

// --- mutate ---
std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::createDirectory(const std::string& taskId, const std::string& path) {
return createTask<react_native_smb::CreateDirectoryOperator>(taskId, std::make_unique<react_native_smb::CreateDirectoryOperator>(path));
return createTask(taskId, std::make_unique<react_native_smb::CreateDirectoryOperator>(path));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::deleteItem(const std::string& taskId, const std::string& path) {
return createTask<react_native_smb::DeleteItemOperator>(taskId, std::make_unique<react_native_smb::DeleteItemOperator>(path));
return createTask(taskId, std::make_unique<react_native_smb::DeleteItemOperator>(path));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::moveItem(const std::string& taskId, const std::string& fromPath, const std::string& toPath) {
return createTask<react_native_smb::MoveItemOperator>(taskId, std::make_unique<react_native_smb::MoveItemOperator>(fromPath, toPath));
return createTask(taskId, std::make_unique<react_native_smb::MoveItemOperator>(fromPath, toPath));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::renameItem(const std::string& taskId, const std::string& currentPath, const std::string& newName) {
return createTask<react_native_smb::RenameItemOperator>(taskId, std::make_unique<react_native_smb::RenameItemOperator>(currentPath, newName));
return createTask(taskId, std::make_unique<react_native_smb::RenameItemOperator>(currentPath, newName));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::copyItem(const std::string& taskId, const std::string& fromPath, const std::string& toPath, bool recursive) {
return createTask<react_native_smb::CopyItemOperator>(taskId, std::make_unique<react_native_smb::CopyItemOperator>(fromPath, toPath, recursive));
return createTask(taskId, std::make_unique<react_native_smb::CopyItemOperator>(fromPath, toPath, recursive));
}

std::shared_ptr<HybridNativeSmbTaskSpec> HybridSMB::duplicateItem(const std::string& taskId, const std::string& path) {
return createTask<react_native_smb::DuplicateItemOperator>(taskId, std::make_unique<react_native_smb::DuplicateItemOperator>(path));
return createTask(taskId, std::make_unique<react_native_smb::DuplicateItemOperator>(path));
}

// --- tasks ---
Expand Down
13 changes: 4 additions & 9 deletions cpp/shared/bridge/HybridSMB.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -57,15 +57,10 @@ class HybridSMB : public HybridReactNativeSmbSpec {
std::mutex poolListenersMutex_;
std::atomic<size_t> poolListenerToken_{1};

enum class ExecutionLane { Shared, Lifecycle };

template <typename OpT>
std::shared_ptr<react_native_smb::SmbTask> startTask(const std::string& taskId, std::unique_ptr<OpT> seedOp,
ExecutionLane lane = ExecutionLane::Shared);

template <typename OpT>
std::shared_ptr<HybridNativeSmbTaskSpec> createTask(const std::string& taskId, std::unique_ptr<OpT> seedOp,
ExecutionLane lane = ExecutionLane::Shared);
// Work operators queue at the pool and run on their own thread once a slot
// is granted; lifecycle operators run on the lifecycle executor.
std::shared_ptr<react_native_smb::SmbTask> startTask(const std::string& taskId, std::unique_ptr<react_native_smb::OperatorBase> op);
std::shared_ptr<HybridNativeSmbTaskSpec> createTask(const std::string& taskId, std::unique_ptr<react_native_smb::OperatorBase> op);

public:
HybridSMB();
Expand Down
11 changes: 3 additions & 8 deletions cpp/shared/connection/ContextRequest.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -2,27 +2,22 @@

#include <atomic>
#include <cstdint>
#include <future>
#include <memory>
#include <string>

#include "PoolTypes.hpp"
#include "../util/SmbErrorMapper.hpp"
#include "SlotReservation.hpp"

namespace react_native_smb {

class PoolContextHandle;

struct ContextRequest {
uint64_t id{0};
AcquireMode mode{AcquireMode::Interactive};
SmbOperatorKind kind{SmbOperatorKind::Initialize};
std::string taskId;
std::promise<PoolContextHandle> promise;
ContextCallbacks callbacks;
// Set while the slot activates; the reservation then fails instead of assigning.
std::atomic<bool> cancelled{false};
std::atomic<bool> fulfilled{false};
std::string errorMessage;
int errorCode{static_cast<int>(SmbErrorCode::Unknown)};
};

using ContextRequestPtr = std::shared_ptr<ContextRequest>;
Expand Down
94 changes: 24 additions & 70 deletions cpp/shared/connection/ContextRequestQueue.cpp
Original file line number Diff line number Diff line change
@@ -1,56 +1,30 @@
#include "ContextRequestQueue.hpp"

#include "PoolContextHandle.hpp"
#include "../core/SmbEnums.hpp"
#include <algorithm>
#include <iterator>
#include <utility>

namespace react_native_smb {

size_t ContextRequestQueue::pendingCount() const {
return interactivePending_.size() + metadataPending_.size();
}

void ContextRequestQueue::drainCancelledFromHead(std::deque<ContextRequestPtr>& queue) {
while (!queue.empty()) {
auto& front = queue.front();
if (!front->cancelled.load(std::memory_order_acquire)) break;
if (!front->fulfilled.load(std::memory_order_acquire)) {
front->fulfilled.store(true, std::memory_order_release);
try {
front->promise.set_value(PoolContextHandle{});
} catch (...) {
}
}
queue.pop_front();
}
}

ContextRequestPtr ContextRequestQueue::enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId) {
void ContextRequestQueue::enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId, ContextCallbacks callbacks) {
auto req = std::make_shared<ContextRequest>();
req->id = nextId_++;
req->mode = mode;
req->kind = kind;
req->taskId = taskId;
req->callbacks = std::move(callbacks);

auto& queue = (mode == AcquireMode::Interactive) ? interactivePending_ : metadataPending_;
queue.push_back(req);
return req;
queue.push_back(std::move(req));
}

ContextRequestPtr ContextRequestQueue::takeNext() {
drainCancelledFromHead(interactivePending_);
if (!interactivePending_.empty()) {
ContextRequestPtr out = std::move(interactivePending_.front());
interactivePending_.pop_front();
return out;
}

drainCancelledFromHead(metadataPending_);
if (!metadataPending_.empty()) {
ContextRequestPtr out = std::move(metadataPending_.front());
metadataPending_.pop_front();
for (auto* queue : {&interactivePending_, &metadataPending_}) {
if (queue->empty()) continue;
ContextRequestPtr out = std::move(queue->front());
queue->pop_front();
return out;
}

return nullptr;
}

Expand All @@ -60,42 +34,22 @@ void ContextRequestQueue::requeueFront(ContextRequestPtr req) {
queue.push_front(std::move(req));
}

void ContextRequestQueue::cancelForTask(const std::string& taskId) {
auto cancelIn = [&](std::deque<ContextRequestPtr>& queue) {
for (auto& req : queue) {
if (req->taskId != taskId) continue;
if (req->fulfilled.load(std::memory_order_acquire)) continue;
req->cancelled.store(true, std::memory_order_release);
req->fulfilled.store(true, std::memory_order_release);
try {
req->promise.set_value(PoolContextHandle{});
} catch (...) {
}
}
};
cancelIn(interactivePending_);
cancelIn(metadataPending_);
}

void ContextRequestQueue::cancelAll() {
auto cancelIn = [](std::deque<ContextRequestPtr>& queue) {
for (auto& req : queue) {
if (req->fulfilled.load(std::memory_order_acquire)) continue;
req->cancelled.store(true, std::memory_order_release);
req->fulfilled.store(true, std::memory_order_release);
try {
req->promise.set_value(PoolContextHandle{});
} catch (...) {
}
}
};
cancelIn(interactivePending_);
cancelIn(metadataPending_);
std::vector<ContextRequestPtr> ContextRequestQueue::takeForTask(const std::string& taskId) {
std::vector<ContextRequestPtr> out;
for (auto* queue : {&interactivePending_, &metadataPending_}) {
auto matches = [&](const ContextRequestPtr& req) { return req->taskId == taskId; };
std::copy_if(queue->begin(), queue->end(), std::back_inserter(out), matches);
queue->erase(std::remove_if(queue->begin(), queue->end(), matches), queue->end());
}
return out;
}

void ContextRequestQueue::removeCancelledFromHead() {
drainCancelledFromHead(interactivePending_);
drainCancelledFromHead(metadataPending_);
std::vector<ContextRequestPtr> ContextRequestQueue::takeAll() {
std::vector<ContextRequestPtr> out(interactivePending_.begin(), interactivePending_.end());
out.insert(out.end(), metadataPending_.begin(), metadataPending_.end());
interactivePending_.clear();
metadataPending_.clear();
return out;
}

} // namespace react_native_smb
14 changes: 7 additions & 7 deletions cpp/shared/connection/ContextRequestQueue.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -3,24 +3,24 @@
#include <cstdint>
#include <deque>
#include <memory>
#include <string>
#include <vector>

#include "ContextRequest.hpp"

namespace react_native_smb {

// Interactive-first FIFO of pending context requests. Not thread-safe; the pool guards it.
class ContextRequestQueue {
public:
ContextRequestPtr enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId);
void enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId, ContextCallbacks callbacks);
ContextRequestPtr takeNext();
void requeueFront(ContextRequestPtr req);
void removeCancelledFromHead();
void cancelForTask(const std::string& taskId);
void cancelAll();
// Remove pending requests so the caller can reject them outside the lock.
std::vector<ContextRequestPtr> takeForTask(const std::string& taskId);
std::vector<ContextRequestPtr> takeAll();

private:
size_t pendingCount() const;
void drainCancelledFromHead(std::deque<ContextRequestPtr>& queue);

std::deque<ContextRequestPtr> interactivePending_;
std::deque<ContextRequestPtr> metadataPending_;
uint64_t nextId_{1};
Expand Down
Loading
Loading