Buckets:
| using namespace node_sqlite3; | |
| Napi::Object Backup::Init(Napi::Env env, Napi::Object exports) { | |
| Napi::HandleScope scope(env); | |
| // declare napi_default_method here as it is only available in Node v14.12.0+ | |
| auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable); | |
| auto t = DefineClass(env, "Backup", { | |
| InstanceMethod("step", &Backup::Step, napi_default_method), | |
| InstanceMethod("finish", &Backup::Finish, napi_default_method), | |
| InstanceAccessor("idle", &Backup::IdleGetter, nullptr), | |
| InstanceAccessor("completed", &Backup::CompletedGetter, nullptr), | |
| InstanceAccessor("failed", &Backup::FailedGetter, nullptr), | |
| InstanceAccessor("remaining", &Backup::RemainingGetter, nullptr), | |
| InstanceAccessor("pageCount", &Backup::PageCountGetter, nullptr), | |
| InstanceAccessor("retryErrors", &Backup::RetryErrorGetter, &Backup::RetryErrorSetter), | |
| }); | |
| exports.Set("Backup", t); | |
| return exports; | |
| } | |
| void Backup::Process() { | |
| if (finished && !queue.empty()) { | |
| return CleanQueue(); | |
| } | |
| while (inited && !locked && !queue.empty()) { | |
| auto call = std::move(queue.front()); | |
| queue.pop(); | |
| call->callback(call->baton); | |
| } | |
| } | |
| void Backup::Schedule(Work_Callback callback, Baton* baton) { | |
| if (finished) { | |
| queue.emplace(new Call(callback, baton)); | |
| CleanQueue(); | |
| } | |
| else if (!inited || locked || !queue.empty()) { | |
| queue.emplace(new Call(callback, baton)); | |
| } | |
| else { | |
| callback(baton); | |
| } | |
| } | |
| template <class T> void Backup::Error(T* baton) { | |
| auto env = baton->backup->Env(); | |
| Napi::HandleScope scope(env); | |
| Backup* backup = baton->backup; | |
| // Fail hard on logic errors. | |
| assert(backup->status != 0); | |
| EXCEPTION(Napi::String::New(env, backup->message), backup->status, exception); | |
| Napi::Function cb = baton->callback.Value(); | |
| if (!cb.IsEmpty() && cb.IsFunction()) { | |
| Napi::Value argv[] = { exception }; | |
| TRY_CATCH_CALL(backup->Value(), cb, 1, argv); | |
| } | |
| else { | |
| Napi::Value argv[] = { Napi::String::New(env, "error"), exception }; | |
| EMIT_EVENT(backup->Value(), 2, argv); | |
| } | |
| } | |
| void Backup::CleanQueue() { | |
| auto env = this->Env(); | |
| Napi::HandleScope scope(env); | |
| if (inited && !queue.empty()) { | |
| // This backup has already been initialized and is now finished. | |
| // Fire error for all remaining items in the queue. | |
| EXCEPTION(Napi::String::New(env, "Backup is already finished"), SQLITE_MISUSE, exception); | |
| Napi::Value argv[] = { exception }; | |
| bool called = false; | |
| // Clear out the queue so that this object can get GC'ed. | |
| while (!queue.empty()) { | |
| auto call = std::move(queue.front()); | |
| queue.pop(); | |
| std::unique_ptr<Baton> baton(call->baton); | |
| Napi::Function cb = baton->callback.Value(); | |
| if (inited && !cb.IsEmpty() && | |
| cb.IsFunction()) { | |
| TRY_CATCH_CALL(Value(), cb, 1, argv); | |
| called = true; | |
| } | |
| } | |
| // When we couldn't call a callback function, emit an error on the | |
| // Backup object. | |
| if (!called) { | |
| Napi::Value info[] = { Napi::String::New(env, "error"), exception }; | |
| EMIT_EVENT(Value(), 2, info); | |
| } | |
| } | |
| else while (!queue.empty()) { | |
| // Just delete all items in the queue; we already fired an event when | |
| // initializing the backup failed. | |
| auto call = std::move(queue.front()); | |
| queue.pop(); | |
| // We don't call the actual callback, so we have to make sure that | |
| // the baton gets destroyed. | |
| delete call->baton; | |
| } | |
| } | |
| Backup::Backup(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Backup>(info) { | |
| auto env = info.Env(); | |
| if (!info.IsConstructCall()) { | |
| Napi::TypeError::New(env, "Use the new operator to create new Backup objects").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| auto length = info.Length(); | |
| if (length <= 0 || !Database::HasInstance(info[0])) { | |
| Napi::TypeError::New(env, "Database object expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| else if (length <= 1 || !info[1].IsString()) { | |
| Napi::TypeError::New(env, "Filename expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| else if (length <= 2 || !info[2].IsString()) { | |
| Napi::TypeError::New(env, "Source database name expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| else if (length <= 3 || !info[3].IsString()) { | |
| Napi::TypeError::New(env, "Destination database name expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| else if (length <= 4 || !info[4].IsBoolean()) { | |
| Napi::TypeError::New(env, "Direction flag expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| else if (length > 5 && !info[5].IsUndefined() && !info[5].IsFunction()) { | |
| Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| this->db = Napi::ObjectWrap<Database>::Unwrap(info[0].As<Napi::Object>()); | |
| this->db->Ref(); | |
| auto filename = info[1].As<Napi::String>(); | |
| auto sourceName = info[2].As<Napi::String>(); | |
| auto destName = info[3].As<Napi::String>(); | |
| auto filenameIsDest = info[4].As<Napi::Boolean>(); | |
| info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("filename", filename)); | |
| info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("sourceName", sourceName)); | |
| info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("destName", destName)); | |
| info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("filenameIsDest", filenameIsDest)); | |
| auto* baton = new InitializeBaton(this->db, info[5].As<Napi::Function>(), this); | |
| baton->filename = filename.Utf8Value(); | |
| baton->sourceName = sourceName.Utf8Value(); | |
| baton->destName = destName.Utf8Value(); | |
| baton->filenameIsDest = filenameIsDest.Value(); | |
| this->db->Schedule(Work_BeginInitialize, baton); | |
| } | |
| void Backup::Work_BeginInitialize(Database::Baton* baton) { | |
| assert(baton->db->open); | |
| baton->db->pending++; | |
| auto env = baton->db->Env(); | |
| CREATE_WORK("sqlite3.Backup.Initialize", Work_Initialize, Work_AfterInitialize); | |
| } | |
| void Backup::Work_Initialize(napi_env e, void* data) { | |
| BACKUP_INIT(InitializeBaton); | |
| // In case stepping fails, we use a mutex to make sure we get the associated | |
| // error message. | |
| auto* mtx = sqlite3_db_mutex(baton->db->_handle); | |
| sqlite3_mutex_enter(mtx); | |
| backup->status = sqlite3_open(baton->filename.c_str(), &backup->_otherDb); | |
| if (backup->status == SQLITE_OK) { | |
| backup->_handle = sqlite3_backup_init( | |
| baton->filenameIsDest ? backup->_otherDb : backup->db->_handle, | |
| baton->destName.c_str(), | |
| baton->filenameIsDest ? backup->db->_handle : backup->_otherDb, | |
| baton->sourceName.c_str()); | |
| } | |
| backup->_destDb = baton->filenameIsDest ? backup->_otherDb : backup->db->_handle; | |
| if (backup->status != SQLITE_OK) { | |
| backup->message = std::string(sqlite3_errmsg(backup->_destDb)); | |
| sqlite3_close(backup->_otherDb); | |
| backup->_otherDb = NULL; | |
| backup->_destDb = NULL; | |
| } | |
| sqlite3_mutex_leave(mtx); | |
| } | |
| void Backup::Work_AfterInitialize(napi_env e, napi_status status, void* data) { | |
| std::unique_ptr<InitializeBaton> baton(static_cast<InitializeBaton*>(data)); | |
| auto* backup = baton->backup; | |
| auto env = backup->Env(); | |
| Napi::HandleScope scope(env); | |
| if (backup->status != SQLITE_OK) { | |
| Error(baton.get()); | |
| backup->FinishAll(); | |
| } | |
| else { | |
| backup->inited = true; | |
| Napi::Function cb = baton->callback.Value(); | |
| if (!cb.IsEmpty() && cb.IsFunction()) { | |
| Napi::Value argv[] = { env.Null() }; | |
| TRY_CATCH_CALL(backup->Value(), cb, 1, argv); | |
| } | |
| } | |
| BACKUP_END(); | |
| } | |
| Napi::Value Backup::Step(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| auto env = backup->Env(); | |
| REQUIRE_ARGUMENT_INTEGER(0, pages); | |
| OPTIONAL_ARGUMENT_FUNCTION(1, callback); | |
| auto* baton = new StepBaton(backup, callback, pages); | |
| backup->GetRetryErrors(baton->retryErrorsSet); | |
| backup->Schedule(Work_BeginStep, baton); | |
| return info.This(); | |
| } | |
| void Backup::Work_BeginStep(Baton* baton) { | |
| BACKUP_BEGIN(Step); | |
| } | |
| void Backup::Work_Step(napi_env e, void* data) { | |
| BACKUP_INIT(StepBaton); | |
| if (backup->_handle) { | |
| backup->status = sqlite3_backup_step(backup->_handle, baton->pages); | |
| backup->remaining = sqlite3_backup_remaining(backup->_handle); | |
| backup->pageCount = sqlite3_backup_pagecount(backup->_handle); | |
| } | |
| if (backup->status != SQLITE_OK) { | |
| // Text of message is a little awkward to get, since the error is not associated | |
| // with a db connection. | |
| // sqlite3_errstr is a relatively new method | |
| backup->message = std::string(sqlite3_errstr(backup->status)); | |
| backup->message = "Sqlite error"; | |
| if (baton->retryErrorsSet.size() > 0) { | |
| if (baton->retryErrorsSet.find(backup->status) == baton->retryErrorsSet.end()) { | |
| backup->FinishSqlite(); | |
| } | |
| } | |
| } | |
| } | |
| void Backup::Work_AfterStep(napi_env e, napi_status status, void* data) { | |
| std::unique_ptr<StepBaton> baton(static_cast<StepBaton*>(data)); | |
| auto* backup = baton->backup; | |
| auto env = backup->Env(); | |
| Napi::HandleScope scope(env); | |
| if (backup->status == SQLITE_DONE) { | |
| backup->completed = true; | |
| } else if (!backup->_handle) { | |
| backup->failed = true; | |
| } | |
| if (backup->status != SQLITE_OK && backup->status != SQLITE_DONE) { | |
| Error(baton.get()); | |
| } | |
| else { | |
| // Fire callbacks. | |
| Napi::Function cb = baton->callback.Value(); | |
| if (!cb.IsEmpty() && cb.IsFunction()) { | |
| Napi::Value argv[] = { env.Null(), Napi::Boolean::New(env, backup->status == SQLITE_DONE) }; | |
| TRY_CATCH_CALL(backup->Value(), cb, 2, argv); | |
| } | |
| } | |
| BACKUP_END(); | |
| } | |
| Napi::Value Backup::Finish(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| auto env = backup->Env(); | |
| OPTIONAL_ARGUMENT_FUNCTION(0, callback); | |
| auto* baton = new Baton(backup, callback); | |
| backup->Schedule(Work_BeginFinish, baton); | |
| return info.This(); | |
| } | |
| void Backup::Work_BeginFinish(Baton* baton) { | |
| BACKUP_BEGIN(Finish); | |
| } | |
| void Backup::Work_Finish(napi_env e, void* data) { | |
| BACKUP_INIT(Baton); | |
| backup->FinishSqlite(); | |
| } | |
| void Backup::Work_AfterFinish(napi_env e, napi_status status, void* data) { | |
| std::unique_ptr<Baton> baton(static_cast<Baton*>(data)); | |
| auto* backup = baton->backup; | |
| auto env = backup->Env(); | |
| Napi::HandleScope scope(env); | |
| backup->FinishAll(); | |
| // Fire callback in case there was one. | |
| Napi::Function cb = baton->callback.Value(); | |
| if (!cb.IsEmpty() && cb.IsFunction()) { | |
| TRY_CATCH_CALL(backup->Value(), cb, 0, NULL); | |
| } | |
| BACKUP_END(); | |
| } | |
| void Backup::FinishAll() { | |
| assert(!finished); | |
| if (!completed && !failed) { | |
| failed = true; | |
| } | |
| finished = true; | |
| CleanQueue(); | |
| FinishSqlite(); | |
| db->Unref(); | |
| } | |
| void Backup::FinishSqlite() { | |
| if (_handle) { | |
| sqlite3_backup_finish(_handle); | |
| _handle = NULL; | |
| } | |
| if (_otherDb) { | |
| sqlite3_close(_otherDb); | |
| _otherDb = NULL; | |
| } | |
| _destDb = NULL; | |
| } | |
| Napi::Value Backup::IdleGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| bool idle = backup->inited && !backup->locked && backup->queue.empty(); | |
| return Napi::Boolean::New(this->Env(), idle); | |
| } | |
| Napi::Value Backup::CompletedGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| return Napi::Boolean::New(this->Env(), backup->completed); | |
| } | |
| Napi::Value Backup::FailedGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| return Napi::Boolean::New(this->Env(), backup->failed); | |
| } | |
| Napi::Value Backup::RemainingGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| return Napi::Number::New(this->Env(), backup->remaining); | |
| } | |
| Napi::Value Backup::PageCountGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| return Napi::Number::New(this->Env(), backup->pageCount); | |
| } | |
| Napi::Value Backup::RetryErrorGetter(const Napi::CallbackInfo& info) { | |
| auto* backup = this; | |
| return backup->retryErrors.Value(); | |
| } | |
| void Backup::RetryErrorSetter(const Napi::CallbackInfo& info, const Napi::Value& value) { | |
| auto* backup = this; | |
| auto env = backup->Env(); | |
| if (!value.IsArray()) { | |
| Napi::Error::New(env, "retryErrors must be an array").ThrowAsJavaScriptException(); | |
| return; | |
| } | |
| Napi::Array array = value.As<Napi::Array>(); | |
| backup->retryErrors.Reset(array, 1); | |
| } | |
| void Backup::GetRetryErrors(std::set<int>& retryErrorsSet) { | |
| retryErrorsSet.clear(); | |
| Napi::Array array = retryErrors.Value(); | |
| auto length = array.Length(); | |
| for (size_t i = 0; i < length; i++) { | |
| Napi::Value code = (array).Get(static_cast<uint32_t>(i)); | |
| if (code.IsNumber()) { | |
| retryErrorsSet.insert(code.As<Napi::Number>().Int32Value()); | |
| } | |
| } | |
| } | |
Xet Storage Details
- Size:
- 13.6 kB
- Xet hash:
- 75754031a408827b1a792aea064f4e89e5357aac89cd60f0ef3918066880f05f
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.