{

// rename folder, so that tests can still create one and add to it

error_code ec;

fs::path oldpath(folder);

fs::path newpath(folder + "_del"); // this can be improved later if needed

fs::rename(oldpath, newpath, ec);

// if renaming failed, then there's nothing to delete

if (ec)

{

// report failures, other than the case when it didn't exist

if (ec != errc::no_such_file_or_directory)

{

cout << "Renaming " << folder << " failed." << endl

<< ec.message() << endl;

}

return;

}

// delete folder in a separate thread

m_cleaners.emplace_back(thread([=]() mutable // ...mostly for fun, to avoid declaring another ec

{

fs::remove_all(newpath, ec);

if (ec)

{

cout << "Deleting " << folder << " failed." << endl

<< ec.message() << endl;

}

}));

{

const auto cwd = fs::current_path();

std::random_device dev;

std::mt19937 prng{dev()};

std::uniform_int_distribution<uint64_t> rand{0};

fs::path path;

for (int i = 0;; ++i)

{

std::ostringstream os;

os << std::hex << rand(prng);

path = cwd / os.str();

if (fs::create_directory(path))

{

break;

}

if (i == maxTries)

{

throw std::runtime_error{"Couldn't create tmp dir"};

}

}

return path;

{

assert(fs::is_regular_file(source));

const auto tmpDir = makeTmpDir();

const auto tmpFile = tmpDir / "copied_file";

fs::copy_file(source, tmpFile);

fs::last_write_time(tmpFile, fs::last_write_time(source));

fs::rename(tmpFile, target);

fs::remove(tmpDir);

{

auto n = p.find_last_of("/");

return n == string::npos ? p : p.substr(n+1);

{

auto n = p.find_last_of("/");

return n == string::npos ? "" : p.substr(0, n-1);

{

#ifdef _WIN32

Sleep(n);

#else

usleep(n * 1000);

#endif

{

// records what we think the tree should look like after sync so we can confirm it

struct ModelNode

{

enum nodetype { file, folder };

nodetype type = folder;

string name;

string content;

vector<unique_ptr<ModelNode>> kids;

ModelNode* parent = nullptr;

string path()

{

string s;

for (auto p = this; p; p = p->parent)

s = "/" + p->name + s;

return s;

}

void addkid(unique_ptr<ModelNode>&& p)

{

p->parent = this;

kids.emplace_back(move(p));

}

bool typematchesnodetype(nodetype_t nodetype)

{

switch (type)

{

case file: return nodetype == FILENODE;

case folder: return nodetype == FOLDERNODE;

}

return false;

}

void print(string prefix="")

{

cout << prefix << name << endl;

prefix.append(name).append("/");

for (const auto &in: kids)

{

in->print(prefix);

}

}

std::unique_ptr<ModelNode> clone()

{

auto result = std::make_unique<ModelNode>();

result->name = name;

result->type = type;

result->content = content;

for (auto& k : kids) result->addkid(k->clone());

return result;

}

};

unique_ptr<ModelNode> makeModelSubfolder(const string& utf8Name)

{

unique_ptr<ModelNode> n(new ModelNode);

n->name = utf8Name;

return n;

}

unique_ptr<ModelNode> makeModelSubfile(const string& utf8Name, string content = {})

{

unique_ptr<ModelNode> n(new ModelNode);

n->name = utf8Name;

n->type = ModelNode::file;

n->content = content.empty() ? utf8Name : std::move(content);

return n;

}

unique_ptr<ModelNode> buildModelSubdirs(const string& prefix, int n, int recurselevel, int filesperdir)

{

if (suppressfiles) filesperdir = 0;

unique_ptr<ModelNode> nn = makeModelSubfolder(prefix);

for (int i = 0; i < filesperdir; ++i)

{

nn->addkid(makeModelSubfile("file" + to_string(i) + "_" + prefix));

}

if (recurselevel > 0)

{

for (int i = 0; i < n; ++i)

{

unique_ptr<ModelNode> sn = buildModelSubdirs(prefix + "_" + to_string(i), n, recurselevel - 1, filesperdir);

sn->parent = nn.get();

nn->addkid(move(sn));

}

}

return nn;

}

ModelNode* childnodebyname(ModelNode* n, const std::string& s)

{

for (auto& m : n->kids)

{

if (m->name == s)

{

return m.get();

}

}

return nullptr;

}

ModelNode* findnode(string path, ModelNode* startnode = nullptr)

{

ModelNode* n = startnode ? startnode : root.get();

while (n && !path.empty())

{

auto pos = path.find("/");

n = childnodebyname(n, path.substr(0, pos));

path.erase(0, pos == string::npos ? path.size() : pos + 1);

}

return n;

}

unique_ptr<ModelNode> removenode(const string& path)

{

ModelNode* n = findnode(path);

if (n && n->parent)

{

unique_ptr<ModelNode> extracted;

ModelNode* parent = n->parent;

auto newend = std::remove_if(parent->kids.begin(), parent->kids.end(), [&extracted, n](unique_ptr<ModelNode>& v) { if (v.get() == n) return extracted = move(v), true; else return false; });

parent->kids.erase(newend, parent->kids.end());

return extracted;

}

return nullptr;

}

bool movenode(const string& sourcepath, const string& destpath)

{

ModelNode* source = findnode(sourcepath);

ModelNode* dest = findnode(destpath);

if (source && source && source->parent && dest)

{

auto replaced_node = removenode(destpath + "/" + source->name);

unique_ptr<ModelNode> n;

ModelNode* parent = source->parent;

auto newend = std::remove_if(parent->kids.begin(), parent->kids.end(), [&n, source](unique_ptr<ModelNode>& v) { if (v.get() == source) return n = move(v), true; else return false; });

parent->kids.erase(newend, parent->kids.end());

if (n)

{

dest->addkid(move(n));

return true;

}

}

return false;

}

bool movetosynctrash(const string& path, const string& syncrootpath)

{

ModelNode* syncroot;

if (!(syncroot = findnode(syncrootpath)))

{

return false;

}

ModelNode* trash;

if (!(trash = childnodebyname(syncroot, DEBRISFOLDER)))

{

auto uniqueptr = makeModelSubfolder(DEBRISFOLDER);

trash = uniqueptr.get();

syncroot->addkid(move(uniqueptr));

}

char today[50];

auto rawtime = time(NULL);

strftime(today, sizeof today, "%F", localtime(&rawtime));

ModelNode* dayfolder;

if (!(dayfolder = findnode(today, trash)))

{

auto uniqueptr = makeModelSubfolder(today);

dayfolder = uniqueptr.get();

trash->addkid(move(uniqueptr));

}

if (auto uniqueptr = removenode(path))

{

dayfolder->addkid(move(uniqueptr));

return true;

}

return false;

}

void ensureLocalDebrisTmpLock(const string& syncrootpath)

{

// if we've downloaded a file then it's put in debris/tmp initially, and there is a lock file

if (ModelNode* syncroot = findnode(syncrootpath))

{

ModelNode* trash;

if (!(trash = childnodebyname(syncroot, DEBRISFOLDER)))

{

auto uniqueptr = makeModelSubfolder(DEBRISFOLDER);

trash = uniqueptr.get();

syncroot->addkid(move(uniqueptr));

}

ModelNode* tmpfolder;

if (!(tmpfolder = findnode("tmp", trash)))

{

auto uniqueptr = makeModelSubfolder("tmp");

tmpfolder = uniqueptr.get();

trash->addkid(move(uniqueptr));

}

ModelNode* lockfile;

if (!(lockfile = findnode("lock", tmpfolder)))

{

tmpfolder->addkid(makeModelSubfile("lock"));

}

}

}

bool removesynctrash(const string& syncrootpath, const string& subpath = "")

{

if (subpath.empty())

{

return removenode(syncrootpath + "/" + DEBRISFOLDER).get();

}

else

{

char today[50];

auto rawtime = time(NULL);

strftime(today, sizeof today, "%F", localtime(&rawtime));

return removenode(syncrootpath + "/" + DEBRISFOLDER + "/" + today + "/" + subpath).get();

}

}

void emulate_rename(std::string nodepath, std::string newname)

{

auto node = findnode(nodepath);

ASSERT_TRUE(!!node);

if (node) node->name = newname;

}

void emulate_move(std::string nodepath, std::string newparentpath)

{

auto removed = removenode(newparentpath + "/" + leafname(nodepath));

ASSERT_TRUE(movenode(nodepath, newparentpath));

}

void emulate_copy(std::string nodepath, std::string newparentpath)

{

auto node = findnode(nodepath);

auto newparent = findnode(newparentpath);

ASSERT_TRUE(!!node);

ASSERT_TRUE(!!newparent);

newparent->addkid(node->clone());

}

void emulate_rename_copy(std::string nodepath, std::string newparentpath, std::string newname)

{

auto node = findnode(nodepath);

auto newparent = findnode(newparentpath);

ASSERT_TRUE(!!node);

ASSERT_TRUE(!!newparent);

auto newnode = node->clone();

newnode->name = newname;

newparent->addkid(std::move(newnode));

}

void emulate_delete(std::string nodepath)

{

auto removed = removenode(nodepath);

// ASSERT_TRUE(!!removed);

}

Model() : root(makeModelSubfolder("root"))

{

}

unique_ptr<ModelNode> root;

{

if (r1) r1->wait();

if (r2) r2->wait();

if (r3) r3->wait();

if (r4) r4->wait();

return (!r1 || r1->get()) && (!r2 || r2->get()) && (!r3 || r3->get()) && (!r4 || r4->get());

{

WAIT_CLASS waiter;

#ifdef GFX_CLASS

GFX_CLASS gfx;

#endif

string client_dbaccess_path;

std::unique_ptr<HttpIO> httpio;

std::unique_ptr<FileSystemAccess> fsaccess;

MegaClient client;

std::atomic<bool> clientthreadexit{false};

bool fatalerror = false;

string clientname;

std::function<void(MegaClient&, promise<bool>&)> nextfunctionMC;

std::promise<bool> nextfunctionMCpromise;

std::function<void(StandardClient&, promise<bool>&)> nextfunctionSC;

std::promise<bool> nextfunctionSCpromise;

std::condition_variable functionDone;

std::mutex functionDoneMutex;

std::string salt;

std::set<fs::path> localFSFilesThatMayDiffer;

fs::path fsBasePath;

handle basefolderhandle = UNDEF;

// thread as last member so everything else is initialised before we start it

std::thread clientthread;

fs::path ensureDir(const fs::path& p)

{

fs::create_directories(p);

return p;

}

StandardClient(const fs::path& basepath, const string& name)

: client_dbaccess_path(ensureDir(basepath / name / "").u8string())

, httpio(new HTTPIO_CLASS)

, fsaccess(new FSACCESS_CLASS)

, client(this, &waiter, httpio.get(), fsaccess.get(),

#ifdef DBACCESS_CLASS

new DBACCESS_CLASS(&client_dbaccess_path),

#else

NULL,

#endif

#ifdef GFX_CLASS

&gfx,

#else

NULL,

#endif

"N9tSBJDC", USER_AGENT.c_str(), THREADS_PER_MEGACLIENT )

, clientname(name)

, fsBasePath(basepath / fs::u8path(name))

, resultproc(client)

, clientthread([this]() { threadloop(); })

{

client.clientname = clientname + " ";

#ifdef GFX_CLASS

gfx.startProcessingThread();

#endif

}

~StandardClient()

{

// shut down any syncs on the same thread, or they stall the client destruction (CancelIo instead of CancelIoEx on the WinDirNotify)

thread_do([](MegaClient& mc, promise<bool>&) {

#ifdef _WIN32

// logout stalls in windows due to the issue above

mc.purgenodesusersabortsc(false);

#else

mc.logout();

#endif

});

clientthreadexit = true;

waiter.notify();

clientthread.join();

}

void localLogout()

{

thread_do([](MegaClient& mc, promise<bool>&) {

#ifdef _WIN32

// logout stalls in windows due to the issue above

mc.purgenodesusersabortsc(false);

#else

mc.locallogout(false);

#endif

});

}

static mutex om;

bool logcb = false;

chrono::steady_clock::time_point lastcb = std::chrono::steady_clock::now();

string lp(LocalNode* ln) { return ln->getLocalPath().toName(*client.fsaccess, FS_UNKNOWN); }

void onCallback() { lastcb = chrono::steady_clock::now(); };

void syncupdate_state(Sync*, syncstate_t state) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_state() " << state << endl; } }

void syncupdate_scanning(bool b) override { if (logcb) { onCallback(); lock_guard<mutex> g(om); cout << clientname << " syncupdate_scanning()" << b << endl; } }

//void syncupdate_local_folder_addition(Sync* s, LocalNode* ln, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_folder_addition() " << lp(ln) << " " << cp << endl; }}

//void syncupdate_local_folder_deletion(Sync*, LocalNode* ln) override { if (logcb) { onCallback(); lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_folder_deletion() " << lp(ln) << endl; }}

void syncupdate_local_folder_addition(Sync*, LocalNode* ln, const char* cp) override { onCallback(); }

void syncupdate_local_folder_deletion(Sync*, LocalNode* ln) override { onCallback(); }

void syncupdate_local_file_addition(Sync*, LocalNode* ln, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_file_addition() " << lp(ln) << " " << cp << endl; }}

void syncupdate_local_file_deletion(Sync*, LocalNode* ln) override { if (logcb) { onCallback(); lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_file_deletion() " << lp(ln) << endl; }}

void syncupdate_local_file_change(Sync*, LocalNode* ln, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_file_change() " << lp(ln) << " " << cp << endl; }}

void syncupdate_local_move(Sync*, LocalNode* ln, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_move() " << lp(ln) << " " << cp << endl; }}

void syncupdate_local_lockretry(bool b) override { if (logcb) { onCallback(); lock_guard<mutex> g(om); cout << clientname << " syncupdate_local_lockretry() " << b << endl; }}

//void syncupdate_get(Sync*, Node* n, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_get()" << n->displaypath() << " " << cp << endl; }}

void syncupdate_put(Sync*, LocalNode* ln, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_put()" << lp(ln) << " " << cp << endl; }}

void syncupdate_remote_file_addition(Sync*, Node* n) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_file_addition() " << n->displaypath() << endl; }}

void syncupdate_remote_file_deletion(Sync*, Node* n) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_file_deletion() " << n->displaypath() << endl; }}

//void syncupdate_remote_folder_addition(Sync*, Node* n) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_folder_addition() " << n->displaypath() << endl; }}

//void syncupdate_remote_folder_deletion(Sync*, Node* n) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_folder_deletion() " << n->displaypath() << endl; }}

void syncupdate_remote_folder_addition(Sync*, Node* n) override { onCallback(); }

void syncupdate_remote_folder_deletion(Sync*, Node* n) override { onCallback(); }

void syncupdate_remote_copy(Sync*, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_copy() " << cp << endl; }}

void syncupdate_remote_move(Sync*, Node* n1, Node* n2) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_move() " << n1->displaypath() << " " << n2->displaypath() << endl; }}

void syncupdate_remote_rename(Sync*, Node* n, const char* cp) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_remote_rename() " << n->displaypath() << " " << cp << endl; }}

//void syncupdate_treestate(LocalNode* ln) override { onCallback(); if (logcb) { lock_guard<mutex> g(om); cout << clientname << " syncupdate_treestate() " << ln->ts << " " << ln->dts << " " << lp(ln) << endl; }}

bool sync_syncable(Sync* sync, const char* name, LocalPath& path, Node*) override

{

return sync_syncable(sync, name, path);

}

bool sync_syncable(Sync*, const char*, LocalPath&) override

{

onCallback();

return true;

}

std::atomic<unsigned> transfersAdded{0}, transfersRemoved{0}, transfersPrepared{0}, transfersFailed{0}, transfersUpdated{0}, transfersComplete{0};

void transfer_added(Transfer*) override { onCallback(); ++transfersAdded; }

void transfer_removed(Transfer*) override { onCallback(); ++transfersRemoved; }

void transfer_prepare(Transfer*) override { onCallback(); ++transfersPrepared; }

void transfer_failed(Transfer*, const Error&, dstime = 0) override { onCallback(); ++transfersFailed; }

void transfer_update(Transfer*) override { onCallback(); ++transfersUpdated; }

void transfer_complete(Transfer*) override { onCallback(); ++transfersComplete; }

void threadloop()

try

{

while (!clientthreadexit)

{

int r = client.wait();

{

std::lock_guard<mutex> g(functionDoneMutex);

if (nextfunctionMC)

{

nextfunctionMC(client, nextfunctionMCpromise);

nextfunctionMC = nullptr;

functionDone.notify_all();

r = Waiter::NEEDEXEC;

}

if (nextfunctionSC)

{

nextfunctionSC(*this, nextfunctionSCpromise);

nextfunctionSC = nullptr;

functionDone.notify_all();

r = Waiter::NEEDEXEC;

}

}

if (r & Waiter::NEEDEXEC)

{

client.exec();

}

}

cout << clientname << " thread exiting naturally" << endl;

}

catch (std::exception& e)

{

cout << clientname << " thread exception, StandardClient " << clientname << " terminated: " << e.what() << endl;

}

catch (...)

{

cout << clientname << " thread exception, StandardClient " << clientname << " terminated" << endl;

}

static bool debugging; // turn this on to prevent the main thread timing out when stepping in the MegaClient

future<bool> thread_do(std::function<void(MegaClient&, promise<bool>&)>&& f)

{

unique_lock<mutex> guard(functionDoneMutex);

nextfunctionMCpromise = promise<bool>();

nextfunctionMC = std::move(f);

waiter.notify();

while (!functionDone.wait_until(guard, chrono::steady_clock::now() + chrono::seconds(600), [this]() { return !nextfunctionMC; }))

{

if (!debugging)

{

nextfunctionMCpromise.set_value(false);

break;

}

}

return nextfunctionMCpromise.get_future();

}

future<bool> thread_do(std::function<void(StandardClient&, promise<bool>&)>&& f)

{

unique_lock<mutex> guard(functionDoneMutex);

nextfunctionSCpromise = promise<bool>();

nextfunctionSC = std::move(f);

waiter.notify();

while (!functionDone.wait_until(guard, chrono::steady_clock::now() + chrono::seconds(600), [this]() { return !nextfunctionSC; }))

{

if (!debugging)

{

nextfunctionSCpromise.set_value(false);

break;

}

}

return nextfunctionSCpromise.get_future();

}

enum resultprocenum { PRELOGIN, LOGIN, FETCHNODES, PUTNODES, UNLINK, MOVENODE, CATCHUP };

void preloginFromEnv(const string& userenv, promise<bool>& pb)

{

string user = getenv(userenv.c_str());

ASSERT_FALSE(user.empty());

resultproc.prepresult(PRELOGIN, ++next_request_tag,

[&](){ client.prelogin(user.c_str()); },

[this, &pb](error e) { pb.set_value(!e); return true; });

}

void loginFromEnv(const string& userenv, const string& pwdenv, promise<bool>& pb)

{

string user = getenv(userenv.c_str());

string pwd = getenv(pwdenv.c_str());

ASSERT_FALSE(user.empty());

ASSERT_FALSE(pwd.empty());

byte pwkey[SymmCipher::KEYLENGTH];

resultproc.prepresult(LOGIN, ++next_request_tag,

[&](){

if (client.accountversion == 1)

{

if (error e = client.pw_key(pwd.c_str(), pwkey))

{

ASSERT_TRUE(false) << "login error: " << e;

}

else

{

client.login(user.c_str(), pwkey);

}

}

else if (client.accountversion == 2 && !salt.empty())

{

client.login2(user.c_str(), pwd.c_str(), &salt);

}

else

{

ASSERT_TRUE(false) << "Login unexpected error";

}

},

[this, &pb](error e) { pb.set_value(!e); return true; });

}

void loginFromSession(const string& session, promise<bool>& pb)

{

resultproc.prepresult(LOGIN, ++next_request_tag,

[&](){ client.login((byte*)session.data(), (int)session.size()); },

[this, &pb](error e) { pb.set_value(!e); return true; });

}

void cloudCopyTreeAs(Node* n1, Node* n2, std::string newname, promise<bool>& pb)

{

resultproc.prepresult(PUTNODES, ++next_request_tag,

[&](){

TreeProcCopy tc;

client.proctree(n1, &tc, false, true);

tc.allocnodes();

auto nc = tc.nc;

client.proctree(n1, &tc, false, true);

tc.nn[0].parenthandle = UNDEF;

SymmCipher key;

AttrMap attrs;

string attrstring;

key.setkey((const ::mega::byte*)tc.nn[0].nodekey.data(), n1->type);

attrs = n1->attrs;

client.fsaccess->normalize(&newname);

attrs.map['n'] = newname;

attrs.getjson(&attrstring);

client.makeattr(&key, tc.nn[0].attrstring, attrstring.c_str());

client.putnodes(n2->nodehandle, tc.nn, nc);

},

[this, &pb](error e) {

pb.set_value(!e);

return true;

});

}

void uploadFolderTree_recurse(handle parent, handle& h, const fs::path& p, vector<NewNode>& newnodes)

{

NewNode n;

client.putnodes_prepareOneFolder(&n, p.filename().u8string());

handle thishandle = n.nodehandle = h++;

n.parenthandle = parent;

newnodes.emplace_back(std::move(n));

for (fs::directory_iterator i(p); i != fs::directory_iterator(); ++i)

{

if (fs::is_directory(*i))

{

uploadFolderTree_recurse(thishandle, h, *i, newnodes);

}

}

}

void uploadFolderTree(fs::path p, Node* n2, promise<bool>& pb)

{

resultproc.prepresult(PUTNODES, ++next_request_tag,

[&](){

vector<NewNode> newnodes;

handle h = 1;

uploadFolderTree_recurse(UNDEF, h, p, newnodes);

auto nn = new NewNode[newnodes.size()];

for (auto i = newnodes.size(); i--; ) nn[i] = std::move(newnodes[i]);

client.putnodes(n2->nodehandle, nn, (int)newnodes.size());

},

[this, &pb](error e) { pb.set_value(!e); return true; });

}

void uploadFilesInTree_recurse(Node* target, const fs::path& p, std::atomic<int>& inprogress, DBTableTransactionCommitter& committer)

{

if (fs::is_regular_file(p))

{

++inprogress;

File* f = new File();

// full local path

f->localname = LocalPath::fromPath(p.u8string(), *client.fsaccess);

f->h = target->nodehandle;

f->name = p.filename().u8string();

client.startxfer(PUT, f, committer);

}

else if (fs::is_directory(p))

{

if (auto newtarget = client.childnodebyname(target, p.filename().u8string().c_str()))

{

for (fs::directory_iterator i(p); i != fs::directory_iterator(); ++i)

{

uploadFilesInTree_recurse(newtarget, *i, inprogress, committer);

}

}

}

}

void uploadFilesInTree(fs::path p, Node* n2, std::atomic<int>& inprogress, std::promise<bool>& pb)

{

resultproc.prepresult(PUTNODES, ++next_request_tag,

[&](){

DBTableTransactionCommitter committer(client.tctable);

uploadFilesInTree_recurse(n2, p, inprogress, committer);

},

[this, &pb, &inprogress](error e)

{

if (!--inprogress)

pb.set_value(true);

return !inprogress;

});

}

class TreeProcPrintTree : public TreeProc

{

public:

void proc(MegaClient* client, Node* n) override

{

//cout << "fetchnodes tree: " << n->displaypath() << endl;;

}

};

// mark node as removed and notify

std::function<void (StandardClient& mc, promise<bool>& pb)> onFetchNodes;

void fetchnodes(promise<bool>& pb)

{

resultproc.prepresult(FETCHNODES, ++next_request_tag,

[&](){ client.fetchnodes(); },

[this, &pb](error e)

{

if (e)

{

pb.set_value(false);

}

else

{

TreeProcPrintTree tppt;

client.proctree(client.nodebyhandle(client.rootnodes[0]), &tppt);

if (onFetchNodes)

{

onFetchNodes(*this, pb);

}

else

{

pb.set_value(true);

}

}

onFetchNodes = nullptr;

return true;

});

}

NewNode makeSubfolder(const string& utf8Name)

{

NewNode newnode;

client.putnodes_prepareOneFolder(&newnode, utf8Name);

return newnode;

}

struct ResultProc

{

MegaClient& client;

ResultProc(MegaClient& c) : client(c) {}

struct id_callback

{

int request_tag = 0;

handle h = UNDEF;

std::function<bool(error)> f;

id_callback(std::function<bool(error)> cf, int tag, handle ch) : request_tag(tag), h(ch), f(cf) {}

};

recursive_mutex mtx; // recursive because sometimes we need to set up new operations during a completion callback

map<resultprocenum, deque<id_callback>> m;

void prepresult(resultprocenum rpe, int tag, std::function<void()>&& requestfunc, std::function<bool(error)>&& f, handle h = UNDEF)

{

lock_guard<recursive_mutex> g(mtx);

auto& entry = m[rpe];

entry.emplace_back(move(f), tag, h);

assert(tag > 0);

int oldtag = client.reqtag;

client.reqtag = tag;

requestfunc();

client.reqtag = oldtag;

client.waiter->notify();

}

void processresult(resultprocenum rpe, error e, handle h = UNDEF)

{

int tag = client.restag;

if (tag == 0 && rpe != CATCHUP)

{

//cout << "received notification of SDK initiated operation " << rpe << " tag " << tag << endl; // too many of those to output

return;

}

if (tag < (2 << 30))

{

cout << "ignoring callback from SDK internal sync operation " << rpe << " tag " << tag << endl;

return;

}

lock_guard<recursive_mutex> g(mtx);

auto& entry = m[rpe];

if (rpe == CATCHUP)

{

while (!entry.empty())

{

entry.front().f(e);

entry.pop_front();

}

return;

}

if (entry.empty())

{

cout << "received notification of operation type " << rpe << " completion but we don't have a record of it. tag: " << tag << endl;

return;

}

if (tag != entry.front().request_tag)

{

cout << "tag mismatch for operation completion of " << rpe << " tag " << tag << ", we expected " << entry.front().request_tag << endl;

return;

}

if (entry.front().f(e))

{

entry.pop_front();

}

}

} resultproc;

void catchup(promise<bool>& pb)

{

resultproc.prepresult(CATCHUP, ++next_request_tag,

[&](){

auto request_sent = thread_do([](StandardClient& sc, promise<bool>& pb) { sc.client.catchup(); pb.set_value(true); });

if (!waitonresults(&request_sent)) {

cout << "catchup not sent" << endl;

}

},

[this, &pb](error e) {

if (e)

{

cout << "catchup reports: " << e << endl;

}

pb.set_value(!e);

return true;

});