Nan::HandleScope scope;

Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);

t->InstanceTemplate()->SetInternalFieldCount(1);

t->SetClassName(Nan::New("Backup").ToLocalChecked());

Nan::SetPrototypeMethod(t, "step", Step);

Nan::SetPrototypeMethod(t, "finish", Finish);

NODE_SET_GETTER(t, "idle", IdleGetter);

NODE_SET_GETTER(t, "completed", CompletedGetter);

NODE_SET_GETTER(t, "failed", FailedGetter);

NODE_SET_GETTER(t, "remaining", RemainingGetter);

NODE_SET_GETTER(t, "pageCount", PageCountGetter);

NODE_SET_SETTER(t, "retryErrors", RetryErrorGetter, RetryErrorSetter);

constructor_template.Reset(t);

Nan::Set(target, Nan::New("Backup").ToLocalChecked(),

Nan::GetFunction(t).ToLocalChecked());

if (finished && !queue.empty()) {

return CleanQueue();

}

while (inited && !locked && !queue.empty()) {

Call* call = queue.front();

queue.pop();

call->callback(call->baton);

delete call;

}

if (finished) {

queue.push(new Call(callback, baton));

CleanQueue();

}

else if (!inited || locked || !queue.empty()) {

queue.push(new Call(callback, baton));

}

else {

callback(baton);

}

Nan::HandleScope scope;

Backup* backup = baton->backup;

// Fail hard on logic errors.

assert(backup->status != 0);

EXCEPTION(backup->message, backup->status, exception);

Local<Function> cb = Nan::New(baton->callback);

if (!cb.IsEmpty() && cb->IsFunction()) {

Local<Value> argv[] = { exception };

TRY_CATCH_CALL(backup->handle(), cb, 1, argv);

}

else {

Local<Value> argv[] = { Nan::New("error").ToLocalChecked(), exception };

EMIT_EVENT(backup->handle(), 2, argv);

}

Nan::HandleScope scope;

if (inited && !queue.empty()) {

// This backup has already been initialized and is now finished.

// Fire error for all remaining items in the queue.

EXCEPTION("Backup is already finished", SQLITE_MISUSE, exception);

Local<Value> argv[] = { exception };

bool called = false;

// Clear out the queue so that this object can get GC'ed.

while (!queue.empty()) {

Call* call = queue.front();

queue.pop();

Local<Function> cb = Nan::New(call->baton->callback);

if (inited && !cb.IsEmpty() &&

cb->IsFunction()) {

TRY_CATCH_CALL(handle(), cb, 1, argv);

called = true;

}

// We don't call the actual callback, so we have to make sure that

// the baton gets destroyed.

delete call->baton;

delete call;

}

// When we couldn't call a callback function, emit an error on the

// Backup object.

if (!called) {

Local<Value> info[] = { Nan::New("error").ToLocalChecked(), exception };

EMIT_EVENT(handle(), 2, info);

}

}

else while (!queue.empty()) {

// Just delete all items in the queue; we already fired an event when

// initializing the backup failed.

Call* call = 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;

delete call;

}

if (!info.IsConstructCall()) {

return Nan::ThrowTypeError("Use the new operator to create new Backup objects");

}

int length = info.Length();

if (length <= 0 || !Database::HasInstance(info[0])) {

return Nan::ThrowTypeError("Database object expected");

}

else if (length <= 1 || !info[1]->IsString()) {

return Nan::ThrowTypeError("Filename expected");

}

else if (length <= 2 || !info[2]->IsString()) {

return Nan::ThrowTypeError("Source database name expected");

}

else if (length <= 3 || !info[3]->IsString()) {

return Nan::ThrowTypeError("Destination database name expected");

}

else if (length <= 4 || !info[4]->IsBoolean()) {

return Nan::ThrowTypeError("Direction flag expected");

}

else if (length > 5 && !info[5]->IsUndefined() && !info[5]->IsFunction()) {

return Nan::ThrowTypeError("Callback expected");

}

Database* db = Nan::ObjectWrap::Unwrap<Database>(info[0].As<Object>());

Local<String> filename = Local<String>::Cast(info[1]);

Local<String> sourceName = Local<String>::Cast(info[2]);

Local<String> destName = Local<String>::Cast(info[3]);

Local<Boolean> filenameIsDest = Local<Boolean>::Cast(info[4]);

Nan::ForceSet(info.This(), Nan::New("filename").ToLocalChecked(), filename, ReadOnly);

Nan::ForceSet(info.This(), Nan::New("sourceName").ToLocalChecked(), sourceName, ReadOnly);

Nan::ForceSet(info.This(), Nan::New("destName").ToLocalChecked(), destName, ReadOnly);

Nan::ForceSet(info.This(), Nan::New("filenameIsDest").ToLocalChecked(), filenameIsDest, ReadOnly);

Backup* backup = new Backup(db);

backup->Wrap(info.This());

InitializeBaton* baton = new InitializeBaton(db, Local<Function>::Cast(info[5]), backup);

baton->filename = std::string(*Nan::Utf8String(filename));

baton->sourceName = std::string(*Nan::Utf8String(sourceName));

baton->destName = std::string(*Nan::Utf8String(destName));

baton->filenameIsDest = Nan::To<bool>(filenameIsDest).FromJust();

db->Schedule(Work_BeginInitialize, baton);

info.GetReturnValue().Set(info.This());

assert(baton->db->open);

baton->db->pending++;

int status = uv_queue_work(uv_default_loop(),

&baton->request, Work_Initialize, (uv_after_work_cb)Work_AfterInitialize);

assert(status == 0);

BACKUP_INIT(InitializeBaton);

// In case stepping fails, we use a mutex to make sure we get the associated

// error message.

sqlite3_mutex* 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);

Nan::HandleScope scope;

BACKUP_INIT(InitializeBaton);

if (backup->status != SQLITE_OK) {

Error(baton);

backup->FinishAll();

}

else {

backup->inited = true;

Local<Function> cb = Nan::New(baton->callback);

if (!cb.IsEmpty() && cb->IsFunction()) {

Local<Value> argv[] = { Nan::Null() };

TRY_CATCH_CALL(backup->handle(), cb, 1, argv);

}

}

BACKUP_END();

Backup* backup = Nan::ObjectWrap::Unwrap<Backup>(info.This());

REQUIRE_ARGUMENT_INTEGER(0, pages);

OPTIONAL_ARGUMENT_FUNCTION(1, callback);

StepBaton* baton = new StepBaton(backup, callback, pages);

backup->GetRetryErrors(baton->retryErrorsSet);

backup->Schedule(Work_BeginStep, baton);

info.GetReturnValue().Set(info.This());

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.

#if SQLITE_VERSION_NUMBER >= 3007015

// sqlite3_errstr is a relatively new method

backup->message = std::string(sqlite3_errstr(backup->status));

#else

backup->message = "Sqlite error";

#endif

if (baton->retryErrorsSet.size() > 0) {

if (baton->retryErrorsSet.find(backup->status) == baton->retryErrorsSet.end()) {

backup->FinishSqlite();

}

}

}

Nan::HandleScope scope;

BACKUP_INIT(StepBaton);

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);

}

else {

// Fire callbacks.

Local<Function> cb = Nan::New(baton->callback);

if (!cb.IsEmpty() && cb->IsFunction()) {

Local<Value> argv[] = { Nan::Null(), Nan::New(backup->status == SQLITE_DONE) };

TRY_CATCH_CALL(backup->handle(), cb, 2, argv);

}

}

BACKUP_END();

Backup* backup = Nan::ObjectWrap::Unwrap<Backup>(info.This());

OPTIONAL_ARGUMENT_FUNCTION(0, callback);

Baton* baton = new Baton(backup, callback);

backup->Schedule(Work_BeginFinish, baton);

info.GetReturnValue().Set(info.This());

Nan::HandleScope scope;

BACKUP_INIT(Baton);

backup->FinishAll();

// Fire callback in case there was one.

Local<Function> cb = Nan::New(baton->callback);

if (!cb.IsEmpty() && cb->IsFunction()) {

TRY_CATCH_CALL(backup->handle(), cb, 0, NULL);

}

BACKUP_END();

assert(!finished);

if (!completed && !failed) {

failed = true;

}

finished = true;

CleanQueue();

FinishSqlite();

db->Unref();

if (_handle) {

sqlite3_backup_finish(_handle);

_handle = NULL;

}

if (_otherDb) {

sqlite3_close(_otherDb);

_otherDb = NULL;

}

_destDb = NULL;

Backup* backup = Nan::ObjectWrap::Unwrap<Backup>(info.This());

bool idle = backup->inited && !backup->locked && backup->queue.empty();

info.GetReturnValue().Set(idle);

Backup* backup = Nan::ObjectWrap::Unwrap<Backup>(info.This());

if (!value->IsArray()) {

return Nan::ThrowError("retryErrors must be an array");

}

Local<Array> array = Local<Array>::Cast(value);

backup->retryErrors.Reset(array);

retryErrorsSet.clear();

Local<Array> array = Nan::New(retryErrors);

int length = array->Length();

for (int i = 0; i < length; i++) {

Local<Value> code = Nan::Get(array, i).ToLocalChecked();

if (code->IsInt32()) {

retryErrorsSet.insert(Nan::To<int32_t>(code).FromJust());

}

}