pj-nodegit 0.27.1 → 0.28.2

package/src/index.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/index.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/str_array_converter.h"
   #include "../include/index_entry.h"
@@ -33,53 +32,54 @@ using namespace node;
     // way of knowing to free these values.
                                                                                                                                               }
 
-  void GitIndex::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitIndex::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("Index").ToLocalChecked());
 
-          Nan::SetPrototypeMethod(tpl, "add", Add);
-            Nan::SetPrototypeMethod(tpl, "addAll", AddAll);
-            Nan::SetPrototypeMethod(tpl, "addByPath", AddBypath);
-            Nan::SetPrototypeMethod(tpl, "caps", Caps);
-            Nan::SetPrototypeMethod(tpl, "checksum", Checksum);
-            Nan::SetPrototypeMethod(tpl, "clear", Clear);
-            Nan::SetPrototypeMethod(tpl, "conflictAdd", ConflictAdd);
-            Nan::SetPrototypeMethod(tpl, "conflictCleanup", ConflictCleanup);
-            Nan::SetPrototypeMethod(tpl, "conflictGet", ConflictGet);
-            Nan::SetPrototypeMethod(tpl, "conflictRemove", ConflictRemove);
-             Nan::SetMethod(tpl, "entryIsConflict", EntryIsConflict);
-             Nan::SetMethod(tpl, "entryStage", EntryStage);
-            Nan::SetPrototypeMethod(tpl, "entryCount", Entrycount);
-            Nan::SetPrototypeMethod(tpl, "find", Find);
-            Nan::SetPrototypeMethod(tpl, "findPrefix", FindPrefix);
-            Nan::SetPrototypeMethod(tpl, "getByIndex", GetByindex);
-            Nan::SetPrototypeMethod(tpl, "getByPath", GetBypath);
-            Nan::SetPrototypeMethod(tpl, "hasConflicts", HasConflicts);
-             Nan::SetMethod(tpl, "open", Open);
-            Nan::SetPrototypeMethod(tpl, "path", Path);
-            Nan::SetPrototypeMethod(tpl, "read", Read);
-            Nan::SetPrototypeMethod(tpl, "readTree", ReadTree);
-            Nan::SetPrototypeMethod(tpl, "remove", Remove);
-            Nan::SetPrototypeMethod(tpl, "removeAll", RemoveAll);
-            Nan::SetPrototypeMethod(tpl, "removeByPath", RemoveBypath);
-            Nan::SetPrototypeMethod(tpl, "removeDirectory", RemoveDirectory);
-            Nan::SetPrototypeMethod(tpl, "setCaps", SetCaps);
-            Nan::SetPrototypeMethod(tpl, "setVersion", SetVersion);
-            Nan::SetPrototypeMethod(tpl, "updateAll", UpdateAll);
-            Nan::SetPrototypeMethod(tpl, "version", Version);
-            Nan::SetPrototypeMethod(tpl, "write", Write);
-            Nan::SetPrototypeMethod(tpl, "writeTree", WriteTree);
-            Nan::SetPrototypeMethod(tpl, "writeTreeTo", WriteTreeTo);
+          Nan::SetPrototypeMethod(tpl, "add", Add, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "addAll", AddAll, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "addByPath", AddBypath, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "caps", Caps, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "checksum", Checksum, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "clear", Clear, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "conflictAdd", ConflictAdd, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "conflictCleanup", ConflictCleanup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "conflictGet", ConflictGet, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "conflictRemove", ConflictRemove, nodegitExternal);
+             Nan::SetMethod(tpl, "entryIsConflict", EntryIsConflict, nodegitExternal);
+             Nan::SetMethod(tpl, "entryStage", EntryStage, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "entryCount", Entrycount, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "find", Find, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "findPrefix", FindPrefix, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getByIndex", GetByindex, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getByPath", GetBypath, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "hasConflicts", HasConflicts, nodegitExternal);
+             Nan::SetMethod(tpl, "open", Open, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "path", Path, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "read", Read, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "readTree", ReadTree, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "remove", Remove, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "removeAll", RemoveAll, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "removeByPath", RemoveBypath, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "removeDirectory", RemoveDirectory, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setCaps", SetCaps, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setVersion", SetVersion, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "updateAll", UpdateAll, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "version", Version, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "write", Write, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "writeTree", WriteTree, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "writeTreeTo", WriteTreeTo, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Index").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitIndex::Template", constructor_template);
+    Nan::Set(target, Nan::New("Index").ToLocalChecked(), constructor_template);
   }
 
  
@@ -92,43 +92,54 @@ NAN_METHOD(GitIndex::Add) {
     return Nan::ThrowError("IndexEntry source_entry is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AddBaton* baton = new AddBaton;
+  AddBaton* baton = new AddBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
-        baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
-// start convert_from_v8 block
-  const git_index_entry * from_source_entry = NULL;
-from_source_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->source_entry = from_source_entry;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  AddWorker *worker = new AddWorker(baton, callback);
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
 
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("source_entry", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+        baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
+            {
+            auto conversionResult = ConfigurableGitIndexEntry::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["source_entry"] = convertedObject;
+            baton->source_entry = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddWorker *worker = new AddWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("source_entry", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::AddWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->source_entry
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::AddWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->source_entry
-    );
-
     int result = git_index_add(
 baton->index,baton->source_entry  );
 
@@ -138,13 +149,34 @@ baton->index,baton->source_entry  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::AddWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.add").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::AddWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+      
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -168,45 +200,15 @@ void GitIndex::AddWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("source_entry"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -238,16 +240,20 @@ void GitIndex::AddWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitIndex::AddAll) {
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AddAllBaton* baton = new AddAllBaton;
+  AddAllBaton* baton = new AddAllBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
       AddAll_globalPayload* globalPayload = new AddAll_globalPayload;
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_pathspec = NULL;
@@ -257,7 +263,7 @@ NAN_METHOD(GitIndex::AddAll) {
           baton->pathspec = from_pathspec;
 // start convert_from_v8 block
   unsigned int from_flags;
-    if (info[1]->IsNumber()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsNumber()) {
       from_flags = (unsigned int)   info[1].As<v8::Number>()->Value();
   }
   else {
@@ -275,32 +281,32 @@ NAN_METHOD(GitIndex::AddAll) {
         }
           baton->payload = globalPayload;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  AddAllWorker *worker = new AddAllWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddAllWorker *worker = new AddAllWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("pathspec", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("flags", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("payload", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("pathspec", info[0]);
+            worker->Reference("flags", info[1]);
+            worker->Reference("payload", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::AddAllWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->pathspec
+          ,baton->payload
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::AddAllWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->pathspec
-            ,baton->payload
-    );
-
     int result = git_index_add_all(
 baton->index,baton->pathspec,baton->flags,baton->callback,baton->payload  );
 
@@ -310,13 +316,35 @@ baton->index,baton->pathspec,baton->flags,baton->callback,baton->payload  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::AddAllWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.addAll").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      delete (AddAll_globalPayload*)baton->payload;
+
+  delete baton;
 }
 
 void GitIndex::AddAllWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+           
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -340,47 +368,15 @@ void GitIndex::AddAllWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("pathspec"));
-              workerArguments.push(GetFromPersistent("flags"));
-              workerArguments.push(GetFromPersistent("payload"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -413,7 +409,13 @@ int GitIndex::AddAll_callback_cppCallback (
     baton.matched_pathspec = matched_pathspec;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(AddAll_callback_async);
+  return baton.ExecuteAsync(AddAll_callback_async, AddAll_callback_cancelAsync);
+}
+
+void GitIndex::AddAll_callback_cancelAsync(void *untypedBaton) {
+  AddAll_CallbackBaton* baton = static_cast<AddAll_CallbackBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitIndex::AddAll_callback_async(void *untypedBaton) {
@@ -429,8 +431,8 @@ void GitIndex::AddAll_callback_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -458,7 +460,7 @@ void GitIndex::AddAll_callback_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitIndex::AddAll_callback_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitIndex::AddAll_callback_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   AddAll_CallbackBaton* baton = static_cast<AddAll_CallbackBaton*>(_baton);
@@ -499,15 +501,19 @@ NAN_METHOD(GitIndex::AddBypath) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AddBypathBaton* baton = new AddBypathBaton;
+  AddBypathBaton* baton = new AddBypathBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_path = NULL;
@@ -524,27 +530,29 @@ NAN_METHOD(GitIndex::AddBypath) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  AddBypathWorker *worker = new AddBypathWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddBypathWorker *worker = new AddBypathWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::AddBypathWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::AddBypathWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_add_bypath(
 baton->index,baton->path  );
 
@@ -554,13 +562,34 @@ baton->index,baton->path  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::AddBypathWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.addByPath").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::AddBypathWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -584,45 +613,15 @@ void GitIndex::AddBypathWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -655,7 +654,7 @@ NAN_METHOD(GitIndex::Caps) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -666,11 +665,11 @@ NAN_METHOD(GitIndex::Caps) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -683,7 +682,7 @@ NAN_METHOD(GitIndex::Checksum) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -698,22 +697,22 @@ NAN_METHOD(GitIndex::Checksum) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -721,35 +720,42 @@ NAN_METHOD(GitIndex::Checksum) {
      */
 NAN_METHOD(GitIndex::Clear) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ClearBaton* baton = new ClearBaton;
+  ClearBaton* baton = new ClearBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  ClearWorker *worker = new ClearWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ClearWorker *worker = new ClearWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
+        worker->Reference<GitIndex>("index", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ClearWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ClearWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-    );
-
     int result = git_index_clear(
 baton->index  );
 
@@ -759,13 +765,34 @@ baton->index  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ClearWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.clear").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ClearWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -789,44 +816,15 @@ void GitIndex::ClearWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -857,74 +855,87 @@ void GitIndex::ClearWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitIndex::ConflictAdd) {
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ConflictAddBaton* baton = new ConflictAddBaton;
+  ConflictAddBaton* baton = new ConflictAddBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
-        baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
-// start convert_from_v8 block
-  const git_index_entry * from_ancestor_entry = NULL;
-    if (info[0]->IsObject()) {
-from_ancestor_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_ancestor_entry = 0;
-  }
-// end convert_from_v8 block
-          baton->ancestor_entry = from_ancestor_entry;
-// start convert_from_v8 block
-  const git_index_entry * from_our_entry = NULL;
-    if (info[1]->IsObject()) {
-from_our_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_our_entry = 0;
-  }
-// end convert_from_v8 block
-          baton->our_entry = from_our_entry;
-// start convert_from_v8 block
-  const git_index_entry * from_their_entry = NULL;
-    if (info[2]->IsObject()) {
-from_their_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_their_entry = 0;
-  }
-// end convert_from_v8 block
-          baton->their_entry = from_their_entry;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  ConflictAddWorker *worker = new ConflictAddWorker(baton, callback);
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
 
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("ancestor_entry", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("our_entry", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("their_entry", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+        baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
+          if (info[0]->IsNull() || info[0]->IsUndefined()) {
+            baton->ancestor_entry = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitIndexEntry::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["ancestor_entry"] = convertedObject;
+            baton->ancestor_entry = convertedObject->GetValue();
+          }
+           if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->our_entry = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitIndexEntry::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["our_entry"] = convertedObject;
+            baton->our_entry = convertedObject->GetValue();
+          }
+           if (info[2]->IsNull() || info[2]->IsUndefined()) {
+            baton->their_entry = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitIndexEntry::fromJavascript(nodegitContext, info[2]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["their_entry"] = convertedObject;
+            baton->their_entry = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ConflictAddWorker *worker = new ConflictAddWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("ancestor_entry", info[0]);
+            worker->Reference("our_entry", info[1]);
+            worker->Reference("their_entry", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ConflictAddWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->ancestor_entry
+          ,baton->our_entry
+          ,baton->their_entry
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ConflictAddWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->ancestor_entry
-            ,baton->our_entry
-            ,baton->their_entry
-    );
-
     int result = git_index_conflict_add(
 baton->index,baton->ancestor_entry,baton->our_entry,baton->their_entry  );
 
@@ -934,13 +945,34 @@ baton->index,baton->ancestor_entry,baton->our_entry,baton->their_entry  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ConflictAddWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.conflictAdd").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ConflictAddWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+            
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -964,47 +996,15 @@ void GitIndex::ConflictAddWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("ancestor_entry"));
-              workerArguments.push(GetFromPersistent("our_entry"));
-              workerArguments.push(GetFromPersistent("their_entry"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1032,35 +1032,42 @@ void GitIndex::ConflictAddWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitIndex::ConflictCleanup) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ConflictCleanupBaton* baton = new ConflictCleanupBaton;
+  ConflictCleanupBaton* baton = new ConflictCleanupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  ConflictCleanupWorker *worker = new ConflictCleanupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ConflictCleanupWorker *worker = new ConflictCleanupWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
+        worker->Reference<GitIndex>("index", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ConflictCleanupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ConflictCleanupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-    );
-
     int result = git_index_conflict_cleanup(
 baton->index  );
 
@@ -1070,13 +1077,34 @@ baton->index  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ConflictCleanupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.conflictCleanup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitIndex::ConflictCleanupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1100,44 +1128,15 @@ void GitIndex::ConflictCleanupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1173,15 +1172,19 @@ NAN_METHOD(GitIndex::ConflictGet) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ConflictGetBaton* baton = new ConflictGetBaton;
+  ConflictGetBaton* baton = new ConflictGetBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_path = NULL;
@@ -1198,27 +1201,29 @@ NAN_METHOD(GitIndex::ConflictGet) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ConflictGetWorker *worker = new ConflictGetWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ConflictGetWorker *worker = new ConflictGetWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ConflictGetWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ConflictGetWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_conflict_get(
 &baton->ancestor_out,&baton->our_out,&baton->their_out,baton->index,baton->path  );
 
@@ -1228,59 +1233,80 @@ void GitIndex::ConflictGetWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ConflictGetWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.conflictGet").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ConflictGetWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
       v8::Local<Object> result = Nan::New<Object>();
 // start convert_to_v8 block
     if (baton->ancestor_out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("index")).ToLocalChecked());
-             to = GitIndexEntry::New(
+             v8ConversionSlot = GitIndexEntry::New(
         baton->ancestor_out,
         false
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        Nan::Set(result, Nan::New("ancestor_out").ToLocalChecked(), to);
+        Nan::Set(result, Nan::New("ancestor_out").ToLocalChecked(), v8ConversionSlot);
 // start convert_to_v8 block
     if (baton->our_out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("index")).ToLocalChecked());
-             to = GitIndexEntry::New(
+             v8ConversionSlot = GitIndexEntry::New(
         baton->our_out,
         false
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        Nan::Set(result, Nan::New("our_out").ToLocalChecked(), to);
+        Nan::Set(result, Nan::New("our_out").ToLocalChecked(), v8ConversionSlot);
 // start convert_to_v8 block
     if (baton->their_out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("index")).ToLocalChecked());
-             to = GitIndexEntry::New(
+             v8ConversionSlot = GitIndexEntry::New(
         baton->their_out,
         false
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        Nan::Set(result, Nan::New("their_out").ToLocalChecked(), to);
-
+        Nan::Set(result, Nan::New("their_out").ToLocalChecked(), v8ConversionSlot);
+              
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1304,45 +1330,15 @@ void GitIndex::ConflictGetWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1375,15 +1371,19 @@ NAN_METHOD(GitIndex::ConflictRemove) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ConflictRemoveBaton* baton = new ConflictRemoveBaton;
+  ConflictRemoveBaton* baton = new ConflictRemoveBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_path = NULL;
@@ -1400,27 +1400,29 @@ NAN_METHOD(GitIndex::ConflictRemove) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ConflictRemoveWorker *worker = new ConflictRemoveWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ConflictRemoveWorker *worker = new ConflictRemoveWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ConflictRemoveWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ConflictRemoveWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_conflict_remove(
 baton->index,baton->path  );
 
@@ -1430,13 +1432,34 @@ baton->index,baton->path  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ConflictRemoveWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.conflictRemove").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ConflictRemoveWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1460,45 +1483,15 @@ void GitIndex::ConflictRemoveWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1540,7 +1533,7 @@ from_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0])
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_entry
@@ -1551,11 +1544,11 @@ from_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0])
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -1577,7 +1570,7 @@ from_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0])
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_entry
@@ -1588,11 +1581,11 @@ from_entry = Nan::ObjectWrap::Unwrap<GitIndexEntry>(Nan::To<v8::Object>(info[0])
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -1605,7 +1598,7 @@ NAN_METHOD(GitIndex::Entrycount) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -1616,11 +1609,11 @@ NAN_METHOD(GitIndex::Entrycount) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -1634,15 +1627,19 @@ NAN_METHOD(GitIndex::Find) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindBaton* baton = new FindBaton;
+  FindBaton* baton = new FindBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->at_pos = (size_t *)malloc(sizeof(size_t ));
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -1660,28 +1657,30 @@ NAN_METHOD(GitIndex::Find) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  FindWorker *worker = new FindWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindWorker *worker = new FindWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::FindWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->at_pos
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::FindWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->at_pos
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_find(
 baton->at_pos,baton->index,baton->path  );
 
@@ -1691,17 +1690,38 @@ baton->at_pos,baton->index,baton->path  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::FindWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.find").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::FindWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>(* baton->at_pos);
+     v8ConversionSlot = Nan::New<Number>(* baton->at_pos);
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1725,45 +1745,15 @@ void GitIndex::FindWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1797,15 +1787,19 @@ NAN_METHOD(GitIndex::FindPrefix) {
     return Nan::ThrowError("String prefix is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindPrefixBaton* baton = new FindPrefixBaton;
+  FindPrefixBaton* baton = new FindPrefixBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->at_pos = (size_t *)malloc(sizeof(size_t ));
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -1823,28 +1817,30 @@ NAN_METHOD(GitIndex::FindPrefix) {
 // end convert_from_v8 block
           baton->prefix = from_prefix;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  FindPrefixWorker *worker = new FindPrefixWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("prefix", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindPrefixWorker *worker = new FindPrefixWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("prefix", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::FindPrefixWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->at_pos
+          ,baton->index
+          ,baton->prefix
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::FindPrefixWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->at_pos
-            ,baton->index
-            ,baton->prefix
-    );
-
     int result = git_index_find_prefix(
 baton->at_pos,baton->index,baton->prefix  );
 
@@ -1854,17 +1850,38 @@ baton->at_pos,baton->index,baton->prefix  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::FindPrefixWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.findPrefix").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::FindPrefixWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>(* baton->at_pos);
+     v8ConversionSlot = Nan::New<Number>(* baton->at_pos);
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1888,45 +1905,15 @@ void GitIndex::FindPrefixWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("prefix"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1968,7 +1955,7 @@ NAN_METHOD(GitIndex::GetByindex) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -1984,19 +1971,19 @@ NAN_METHOD(GitIndex::GetByindex) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
-        to = GitIndexEntry::New(
+        v8ConversionSlot = GitIndexEntry::New(
         result,
         false
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2026,7 +2013,7 @@ NAN_METHOD(GitIndex::GetBypath) {
 // end convert_from_v8 block
 // start convert_from_v8 block
   int from_stage;
-    if (info[1]->IsNumber()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsNumber()) {
       from_stage = (int)   info[1].As<v8::Number>()->Value();
   }
   else {
@@ -2037,7 +2024,7 @@ NAN_METHOD(GitIndex::GetBypath) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -2056,19 +2043,19 @@ NAN_METHOD(GitIndex::GetBypath) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
-        to = GitIndexEntry::New(
+        v8ConversionSlot = GitIndexEntry::New(
         result,
         false
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2081,7 +2068,7 @@ NAN_METHOD(GitIndex::HasConflicts) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -2092,11 +2079,11 @@ NAN_METHOD(GitIndex::HasConflicts) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2110,15 +2097,19 @@ NAN_METHOD(GitIndex::Open) {
     return Nan::ThrowError("String index_path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  OpenBaton* baton = new OpenBaton;
+  OpenBaton* baton = new OpenBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   const char * from_index_path = NULL;
 
@@ -2134,25 +2125,27 @@ NAN_METHOD(GitIndex::Open) {
 // end convert_from_v8 block
           baton->index_path = from_index_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  OpenWorker *worker = new OpenWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  OpenWorker *worker = new OpenWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("index_path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+           worker->Reference("index_path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::OpenWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index_path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::OpenWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index_path
-    );
-
     int result = git_index_open(
 &baton->out,baton->index_path  );
 
@@ -2162,12 +2155,34 @@ void GitIndex::OpenWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::OpenWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.open").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_index_free(baton->out);
+
+  delete baton;
 }
 
 void GitIndex::OpenWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2179,18 +2194,18 @@ void GitIndex::OpenWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitIndex::New(
+         v8ConversionSlot = GitIndex::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2214,45 +2229,15 @@ void GitIndex::OpenWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("index_path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2269,6 +2254,7 @@ void GitIndex::OpenWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_index_free(baton->out);
   }
 
 
@@ -2285,7 +2271,7 @@ NAN_METHOD(GitIndex::Path) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -2300,17 +2286,17 @@ NAN_METHOD(GitIndex::Path) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2319,19 +2305,23 @@ NAN_METHOD(GitIndex::Path) {
      */
 NAN_METHOD(GitIndex::Read) {
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ReadBaton* baton = new ReadBaton;
+  ReadBaton* baton = new ReadBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   int from_force;
-    if (info[0]->IsNumber()) {
+    if ((info.Length() - 1) > 0 && info[0]->IsNumber()) {
       from_force = (int)   info[0].As<v8::Number>()->Value();
   }
   else {
@@ -2340,26 +2330,28 @@ NAN_METHOD(GitIndex::Read) {
 // end convert_from_v8 block
           baton->force = from_force;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ReadWorker *worker = new ReadWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("force", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ReadWorker *worker = new ReadWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("force", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ReadWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ReadWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-    );
-
     int result = git_index_read(
 baton->index,baton->force  );
 
@@ -2369,13 +2361,34 @@ baton->index,baton->force  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ReadWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.read").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ReadWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2399,45 +2412,15 @@ void GitIndex::ReadWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("force"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2470,15 +2453,19 @@ NAN_METHOD(GitIndex::ReadTree) {
     return Nan::ThrowError("Tree tree is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ReadTreeBaton* baton = new ReadTreeBaton;
+  ReadTreeBaton* baton = new ReadTreeBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_tree * from_tree = NULL;
@@ -2486,27 +2473,29 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[0]).ToLoca
 // end convert_from_v8 block
           baton->tree = from_tree;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ReadTreeWorker *worker = new ReadTreeWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("tree", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ReadTreeWorker *worker = new ReadTreeWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+             worker->Reference<GitTree>("tree", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::ReadTreeWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->tree
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::ReadTreeWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->tree
-    );
-
     int result = git_index_read_tree(
 baton->index,baton->tree  );
 
@@ -2516,13 +2505,34 @@ baton->index,baton->tree  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::ReadTreeWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.readTree").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::ReadTreeWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2546,45 +2556,15 @@ void GitIndex::ReadTreeWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("tree"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2622,15 +2602,19 @@ NAN_METHOD(GitIndex::Remove) {
     return Nan::ThrowError("Number stage is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  RemoveBaton* baton = new RemoveBaton;
+  RemoveBaton* baton = new RemoveBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_path = NULL;
@@ -2652,29 +2636,30 @@ NAN_METHOD(GitIndex::Remove) {
 // end convert_from_v8 block
           baton->stage = from_stage;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  RemoveWorker *worker = new RemoveWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("stage", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RemoveWorker *worker = new RemoveWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+            worker->Reference("stage", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::RemoveWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::RemoveWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_remove(
 baton->index,baton->path,baton->stage  );
 
@@ -2684,13 +2669,34 @@ baton->index,baton->path,baton->stage  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::RemoveWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.remove").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::RemoveWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2714,46 +2720,15 @@ void GitIndex::RemoveWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
-              workerArguments.push(GetFromPersistent("stage"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2784,16 +2759,20 @@ void GitIndex::RemoveWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitIndex::RemoveAll) {
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  RemoveAllBaton* baton = new RemoveAllBaton;
+  RemoveAllBaton* baton = new RemoveAllBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
       RemoveAll_globalPayload* globalPayload = new RemoveAll_globalPayload;
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_pathspec = NULL;
@@ -2811,30 +2790,31 @@ NAN_METHOD(GitIndex::RemoveAll) {
         }
           baton->payload = globalPayload;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  RemoveAllWorker *worker = new RemoveAllWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("pathspec", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("payload", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RemoveAllWorker *worker = new RemoveAllWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("pathspec", info[0]);
+            worker->Reference("payload", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::RemoveAllWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->pathspec
+          ,baton->payload
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::RemoveAllWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->pathspec
-            ,baton->payload
-    );
-
     int result = git_index_remove_all(
 baton->index,baton->pathspec,baton->callback,baton->payload  );
 
@@ -2844,13 +2824,35 @@ baton->index,baton->pathspec,baton->callback,baton->payload  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::RemoveAllWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.removeAll").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      delete (RemoveAll_globalPayload*)baton->payload;
+
+  delete baton;
 }
 
 void GitIndex::RemoveAllWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2874,46 +2876,15 @@ void GitIndex::RemoveAllWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("pathspec"));
-              workerArguments.push(GetFromPersistent("payload"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2946,7 +2917,13 @@ int GitIndex::RemoveAll_callback_cppCallback (
     baton.matched_pathspec = matched_pathspec;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(RemoveAll_callback_async);
+  return baton.ExecuteAsync(RemoveAll_callback_async, RemoveAll_callback_cancelAsync);
+}
+
+void GitIndex::RemoveAll_callback_cancelAsync(void *untypedBaton) {
+  RemoveAll_CallbackBaton* baton = static_cast<RemoveAll_CallbackBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitIndex::RemoveAll_callback_async(void *untypedBaton) {
@@ -2962,8 +2939,8 @@ void GitIndex::RemoveAll_callback_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -2991,7 +2968,7 @@ void GitIndex::RemoveAll_callback_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitIndex::RemoveAll_callback_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitIndex::RemoveAll_callback_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   RemoveAll_CallbackBaton* baton = static_cast<RemoveAll_CallbackBaton*>(_baton);
@@ -3032,15 +3009,19 @@ NAN_METHOD(GitIndex::RemoveBypath) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  RemoveBypathBaton* baton = new RemoveBypathBaton;
+  RemoveBypathBaton* baton = new RemoveBypathBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_path = NULL;
@@ -3057,27 +3038,29 @@ NAN_METHOD(GitIndex::RemoveBypath) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  RemoveBypathWorker *worker = new RemoveBypathWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RemoveBypathWorker *worker = new RemoveBypathWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::RemoveBypathWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::RemoveBypathWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->path
-    );
-
     int result = git_index_remove_bypath(
 baton->index,baton->path  );
 
@@ -3087,13 +3070,34 @@ baton->index,baton->path  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::RemoveBypathWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.removeByPath").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::RemoveBypathWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3117,45 +3121,15 @@ void GitIndex::RemoveBypathWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3193,15 +3167,19 @@ NAN_METHOD(GitIndex::RemoveDirectory) {
     return Nan::ThrowError("Number stage is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  RemoveDirectoryBaton* baton = new RemoveDirectoryBaton;
+  RemoveDirectoryBaton* baton = new RemoveDirectoryBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_dir = NULL;
@@ -3223,29 +3201,30 @@ NAN_METHOD(GitIndex::RemoveDirectory) {
 // end convert_from_v8 block
           baton->stage = from_stage;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  RemoveDirectoryWorker *worker = new RemoveDirectoryWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("dir", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("stage", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RemoveDirectoryWorker *worker = new RemoveDirectoryWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("dir", info[0]);
+            worker->Reference("stage", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::RemoveDirectoryWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->dir
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::RemoveDirectoryWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->dir
-    );
-
     int result = git_index_remove_directory(
 baton->index,baton->dir,baton->stage  );
 
@@ -3255,13 +3234,34 @@ baton->index,baton->dir,baton->stage  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::RemoveDirectoryWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.removeDirectory").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::RemoveDirectoryWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3285,46 +3285,15 @@ void GitIndex::RemoveDirectoryWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("dir"));
-              workerArguments.push(GetFromPersistent("stage"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3366,7 +3335,7 @@ NAN_METHOD(GitIndex::SetCaps) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -3378,11 +3347,11 @@ NAN_METHOD(GitIndex::SetCaps) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3404,7 +3373,7 @@ NAN_METHOD(GitIndex::SetVersion) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -3416,11 +3385,11 @@ NAN_METHOD(GitIndex::SetVersion) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -3431,16 +3400,20 @@ NAN_METHOD(GitIndex::SetVersion) {
      */
 NAN_METHOD(GitIndex::UpdateAll) {
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  UpdateAllBaton* baton = new UpdateAllBaton;
+  UpdateAllBaton* baton = new UpdateAllBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
       UpdateAll_globalPayload* globalPayload = new UpdateAll_globalPayload;
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_pathspec = NULL;
@@ -3458,30 +3431,31 @@ NAN_METHOD(GitIndex::UpdateAll) {
         }
           baton->payload = globalPayload;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  UpdateAllWorker *worker = new UpdateAllWorker(baton, callback);
-
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("pathspec", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("payload", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  UpdateAllWorker *worker = new UpdateAllWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+           worker->Reference("pathspec", info[0]);
+            worker->Reference("payload", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::UpdateAllWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+          ,baton->pathspec
+          ,baton->payload
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::UpdateAllWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-            ,baton->pathspec
-            ,baton->payload
-    );
-
     int result = git_index_update_all(
 baton->index,baton->pathspec,baton->callback,baton->payload  );
 
@@ -3491,13 +3465,35 @@ baton->index,baton->pathspec,baton->callback,baton->payload  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::UpdateAllWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.updateAll").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      delete (UpdateAll_globalPayload*)baton->payload;
+
+  delete baton;
 }
 
 void GitIndex::UpdateAllWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3521,46 +3517,15 @@ void GitIndex::UpdateAllWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("pathspec"));
-              workerArguments.push(GetFromPersistent("payload"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3593,7 +3558,13 @@ int GitIndex::UpdateAll_callback_cppCallback (
     baton.matched_pathspec = matched_pathspec;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(UpdateAll_callback_async);
+  return baton.ExecuteAsync(UpdateAll_callback_async, UpdateAll_callback_cancelAsync);
+}
+
+void GitIndex::UpdateAll_callback_cancelAsync(void *untypedBaton) {
+  UpdateAll_CallbackBaton* baton = static_cast<UpdateAll_CallbackBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitIndex::UpdateAll_callback_async(void *untypedBaton) {
@@ -3609,8 +3580,8 @@ void GitIndex::UpdateAll_callback_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -3638,7 +3609,7 @@ void GitIndex::UpdateAll_callback_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitIndex::UpdateAll_callback_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitIndex::UpdateAll_callback_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   UpdateAll_CallbackBaton* baton = static_cast<UpdateAll_CallbackBaton*>(_baton);
@@ -3679,7 +3650,7 @@ NAN_METHOD(GitIndex::Version) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue()
@@ -3690,11 +3661,11 @@ NAN_METHOD(GitIndex::Version) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -3702,35 +3673,42 @@ NAN_METHOD(GitIndex::Version) {
      */
 NAN_METHOD(GitIndex::Write) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  WriteBaton* baton = new WriteBaton;
+  WriteBaton* baton = new WriteBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  WriteWorker *worker = new WriteWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  WriteWorker *worker = new WriteWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
+        worker->Reference<GitIndex>("index", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::WriteWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->index
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::WriteWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->index
-    );
-
     int result = git_index_write(
 baton->index  );
 
@@ -3740,13 +3718,34 @@ baton->index  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::WriteWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.write").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::WriteWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3770,44 +3769,15 @@ void GitIndex::WriteWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3836,37 +3806,44 @@ void GitIndex::WriteWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitIndex::WriteTree) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  WriteTreeBaton* baton = new WriteTreeBaton;
+  WriteTreeBaton* baton = new WriteTreeBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_oid *)malloc(sizeof(git_oid ));
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  WriteTreeWorker *worker = new WriteTreeWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  WriteTreeWorker *worker = new WriteTreeWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
+        worker->Reference<GitIndex>("index", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::WriteTreeWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->index
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::WriteTreeWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->index
-    );
-
     int result = git_index_write_tree(
 baton->out,baton->index  );
 
@@ -3876,25 +3853,46 @@ baton->out,baton->index  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::WriteTreeWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.writeTree").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::WriteTreeWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3918,44 +3916,15 @@ void GitIndex::WriteTreeWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3989,15 +3958,19 @@ NAN_METHOD(GitIndex::WriteTreeTo) {
     return Nan::ThrowError("Repository repo is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  WriteTreeToBaton* baton = new WriteTreeToBaton;
+  WriteTreeToBaton* baton = new WriteTreeToBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_oid *)malloc(sizeof(git_oid ));
         baton->index = Nan::ObjectWrap::Unwrap<GitIndex>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -4006,28 +3979,30 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->repo = from_repo;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  WriteTreeToWorker *worker = new WriteTreeToWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  WriteTreeToWorker *worker = new WriteTreeToWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("index", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitIndex>("index", info.This());
+             worker->Reference<GitRepository>("repo", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitIndex::WriteTreeToWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->index
+          ,baton->repo
+  );
+
+  return lockMaster;
+}
+
 void GitIndex::WriteTreeToWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->index
-            ,baton->repo
-    );
-
     int result = git_index_write_tree_to(
 baton->out,baton->index,baton->repo  );
 
@@ -4037,25 +4012,46 @@ baton->out,baton->index,baton->repo  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitIndex::WriteTreeToWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Index.writeTreeTo").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitIndex::WriteTreeToWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -4079,45 +4075,15 @@ void GitIndex::WriteTreeToWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }