pj-nodegit 0.27.0 → 0.28.1

package/src/submodule.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/submodule.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/repository.h"
   #include "../include/submodule_update_options.h"
@@ -31,51 +30,52 @@ using namespace node;
     // way of knowing to free these values.
                                                                                                                                   }
 
-  void GitSubmodule::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitSubmodule::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("Submodule").ToLocalChecked());
 
-          Nan::SetPrototypeMethod(tpl, "addFinalize", AddFinalize);
-             Nan::SetMethod(tpl, "addSetup", AddSetup);
-            Nan::SetPrototypeMethod(tpl, "addToIndex", AddToIndex);
-            Nan::SetPrototypeMethod(tpl, "branch", Branch);
-            Nan::SetPrototypeMethod(tpl, "clone", Clone);
-            Nan::SetPrototypeMethod(tpl, "fetchRecurseSubmodules", FetchRecurseSubmodules);
-             Nan::SetMethod(tpl, "foreach", Foreach);
-            Nan::SetPrototypeMethod(tpl, "headId", HeadId);
-            Nan::SetPrototypeMethod(tpl, "ignore", Ignore);
-            Nan::SetPrototypeMethod(tpl, "indexId", IndexId);
-            Nan::SetPrototypeMethod(tpl, "init", Init);
-            Nan::SetPrototypeMethod(tpl, "location", Location);
-             Nan::SetMethod(tpl, "lookup", Lookup);
-            Nan::SetPrototypeMethod(tpl, "name", Name);
-            Nan::SetPrototypeMethod(tpl, "open", Open);
-            Nan::SetPrototypeMethod(tpl, "owner", Owner);
-            Nan::SetPrototypeMethod(tpl, "path", Path);
-            Nan::SetPrototypeMethod(tpl, "reload", Reload);
-            Nan::SetPrototypeMethod(tpl, "repoInit", RepoInit);
-             Nan::SetMethod(tpl, "resolveUrl", ResolveUrl);
-             Nan::SetMethod(tpl, "setBranch", SetBranch);
-             Nan::SetMethod(tpl, "setFetchRecurseSubmodules", SetFetchRecurseSubmodules);
-             Nan::SetMethod(tpl, "setIgnore", SetIgnore);
-             Nan::SetMethod(tpl, "setUpdate", SetUpdate);
-             Nan::SetMethod(tpl, "setUrl", SetUrl);
-             Nan::SetMethod(tpl, "status", Status);
-            Nan::SetPrototypeMethod(tpl, "sync", Sync);
-            Nan::SetPrototypeMethod(tpl, "update", Update);
-            Nan::SetPrototypeMethod(tpl, "updateStrategy", UpdateStrategy);
-            Nan::SetPrototypeMethod(tpl, "url", Url);
-            Nan::SetPrototypeMethod(tpl, "wdId", WdId);
+          Nan::SetPrototypeMethod(tpl, "addFinalize", AddFinalize, nodegitExternal);
+             Nan::SetMethod(tpl, "addSetup", AddSetup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "addToIndex", AddToIndex, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "branch", Branch, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "clone", Clone, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "fetchRecurseSubmodules", FetchRecurseSubmodules, nodegitExternal);
+             Nan::SetMethod(tpl, "foreach", Foreach, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "headId", HeadId, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "ignore", Ignore, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "indexId", IndexId, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "init", Init, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "location", Location, nodegitExternal);
+             Nan::SetMethod(tpl, "lookup", Lookup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "name", Name, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "open", Open, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "owner", Owner, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "path", Path, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "reload", Reload, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "repoInit", RepoInit, nodegitExternal);
+             Nan::SetMethod(tpl, "resolveUrl", ResolveUrl, nodegitExternal);
+             Nan::SetMethod(tpl, "setBranch", SetBranch, nodegitExternal);
+             Nan::SetMethod(tpl, "setFetchRecurseSubmodules", SetFetchRecurseSubmodules, nodegitExternal);
+             Nan::SetMethod(tpl, "setIgnore", SetIgnore, nodegitExternal);
+             Nan::SetMethod(tpl, "setUpdate", SetUpdate, nodegitExternal);
+             Nan::SetMethod(tpl, "setUrl", SetUrl, nodegitExternal);
+             Nan::SetMethod(tpl, "status", Status, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "sync", Sync, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "update", Update, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "updateStrategy", UpdateStrategy, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "url", Url, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "wdId", WdId, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Submodule").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitSubmodule::Template", constructor_template);
+    Nan::Set(target, Nan::New("Submodule").ToLocalChecked(), constructor_template);
   }
 
  
@@ -83,35 +83,42 @@ using namespace node;
      */
 NAN_METHOD(GitSubmodule::AddFinalize) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AddFinalizeBaton* baton = new AddFinalizeBaton;
+  AddFinalizeBaton* baton = new AddFinalizeBaton();
 
   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->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  AddFinalizeWorker *worker = new AddFinalizeWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddFinalizeWorker *worker = new AddFinalizeWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("submodule", info.This());
+        worker->Reference<GitSubmodule>("submodule", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::AddFinalizeWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::AddFinalizeWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-    );
-
     int result = git_submodule_add_finalize(
 baton->submodule  );
 
@@ -121,13 +128,34 @@ baton->submodule  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::AddFinalizeWorker::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("Submodule.addFinalize").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 GitSubmodule::AddFinalizeWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -151,44 +179,15 @@ void GitSubmodule::AddFinalizeWorker::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);
-          }
         }
       }
 
@@ -237,15 +236,19 @@ NAN_METHOD(GitSubmodule::AddSetup) {
     return Nan::ThrowError("Number use_gitlink is required.");
   }
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AddSetupBaton* baton = new AddSetupBaton;
+  AddSetupBaton* baton = new AddSetupBaton();
 
   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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -285,33 +288,32 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->use_gitlink = from_use_gitlink;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  AddSetupWorker *worker = new AddSetupWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("use_gitlink", Nan::To<v8::Object>(info[3]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddSetupWorker *worker = new AddSetupWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("url", info[1]);
+            worker->Reference("path", info[2]);
+            worker->Reference("use_gitlink", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::AddSetupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->url
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::AddSetupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->url
-            ,baton->path
-    );
-
     int result = git_submodule_add_setup(
 &baton->out,baton->repo,baton->url,baton->path,baton->use_gitlink  );
 
@@ -321,12 +323,34 @@ void GitSubmodule::AddSetupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::AddSetupWorker::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("Submodule.addSetup").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);
+  }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitSubmodule::AddSetupWorker::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);
@@ -338,18 +362,18 @@ void GitSubmodule::AddSetupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitSubmodule::New(
+         v8ConversionSlot = GitSubmodule::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
@@ -373,48 +397,15 @@ void GitSubmodule::AddSetupWorker::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"));
-              workerArguments.push(GetFromPersistent("url"));
-              workerArguments.push(GetFromPersistent("path"));
-              workerArguments.push(GetFromPersistent("use_gitlink"));
       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);
-          }
         }
       }
 
@@ -431,6 +422,7 @@ void GitSubmodule::AddSetupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -447,15 +439,19 @@ NAN_METHOD(GitSubmodule::AddToIndex) {
     return Nan::ThrowError("Number write_index 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.");
   }
 
-  AddToIndexBaton* baton = new AddToIndexBaton;
+  AddToIndexBaton* baton = new AddToIndexBaton();
 
   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->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 // start convert_from_v8 block
   int from_write_index;
@@ -463,26 +459,28 @@ NAN_METHOD(GitSubmodule::AddToIndex) {
 // end convert_from_v8 block
           baton->write_index = from_write_index;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  AddToIndexWorker *worker = new AddToIndexWorker(baton, callback);
-
-        worker->SaveToPersistent("submodule", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("write_index", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AddToIndexWorker *worker = new AddToIndexWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitSubmodule>("submodule", info.This());
+           worker->Reference("write_index", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::AddToIndexWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::AddToIndexWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-    );
-
     int result = git_submodule_add_to_index(
 baton->submodule,baton->write_index  );
 
@@ -492,13 +490,34 @@ baton->submodule,baton->write_index  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::AddToIndexWorker::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("Submodule.addToIndex").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 GitSubmodule::AddToIndexWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -522,45 +541,15 @@ void GitSubmodule::AddToIndexWorker::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("write_index"));
       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);
-          }
         }
       }
 
@@ -593,7 +582,7 @@ NAN_METHOD(GitSubmodule::Branch) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -608,17 +597,17 @@ NAN_METHOD(GitSubmodule::Branch) {
           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));
   }
 }
   
@@ -632,43 +621,54 @@ NAN_METHOD(GitSubmodule::Clone) {
     return Nan::ThrowError("SubmoduleUpdateOptions opts 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.");
   }
 
-  CloneBaton* baton = new CloneBaton;
+  CloneBaton* baton = new CloneBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
-        baton->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
-// start convert_from_v8 block
-  const git_submodule_update_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitSubmoduleUpdateOptions>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  CloneWorker *worker = new CloneWorker(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("submodule", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+        baton->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
+            {
+            auto conversionResult = ConfigurableGitSubmoduleUpdateOptions::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CloneWorker *worker = new CloneWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitSubmodule>("submodule", info.This());
+           worker->Reference("opts", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::CloneWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+          ,baton->opts
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::CloneWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-            ,baton->opts
-    );
-
     int result = git_submodule_clone(
 &baton->out,baton->submodule,baton->opts  );
 
@@ -678,25 +678,47 @@ void GitSubmodule::CloneWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::CloneWorker::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("Submodule.clone").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_repository_free(baton->out);
+
+  delete baton;
 }
 
 void GitSubmodule::CloneWorker::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 = GitRepository::New(
+        v8ConversionSlot = GitRepository::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
@@ -720,45 +742,15 @@ void GitSubmodule::CloneWorker::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("opts"));
       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);
-          }
         }
       }
 
@@ -775,6 +767,7 @@ void GitSubmodule::CloneWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_repository_free(baton->out);
   }
 
 
@@ -791,7 +784,7 @@ NAN_METHOD(GitSubmodule::FetchRecurseSubmodules) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -802,11 +795,11 @@ NAN_METHOD(GitSubmodule::FetchRecurseSubmodules) {
     );
 
 
-      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));
   }
 }
   
@@ -824,16 +817,20 @@ NAN_METHOD(GitSubmodule::Foreach) {
   if (info.Length() == 1 || !info[1]->IsFunction()) {
     return Nan::ThrowError("SubmoduleCb callback is required.");
   }
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ForeachBaton* baton = new ForeachBaton;
+  ForeachBaton* baton = new ForeachBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
       Foreach_globalPayload* globalPayload = new Foreach_globalPayload;
+
+  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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -849,28 +846,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
         }
           baton->payload = globalPayload;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  ForeachWorker *worker = new ForeachWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ForeachWorker *worker = new ForeachWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("payload", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("payload", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::ForeachWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->payload
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::ForeachWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->payload
-    );
-
     int result = git_submodule_foreach(
 baton->repo,baton->callback,baton->payload  );
 
@@ -880,13 +878,35 @@ baton->repo,baton->callback,baton->payload  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::ForeachWorker::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("Submodule.foreach").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 (Foreach_globalPayload*)baton->payload;
+
+  delete baton;
 }
 
 void GitSubmodule::ForeachWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -910,46 +930,15 @@ void GitSubmodule::ForeachWorker::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"));
-              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);
-          }
         }
       }
 
@@ -982,7 +971,13 @@ int GitSubmodule::Foreach_callback_cppCallback (
     baton.name = name;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(Foreach_callback_async);
+  return baton.ExecuteAsync(Foreach_callback_async, Foreach_callback_cancelAsync);
+}
+
+void GitSubmodule::Foreach_callback_cancelAsync(void *untypedBaton) {
+  Foreach_CallbackBaton* baton = static_cast<Foreach_CallbackBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitSubmodule::Foreach_callback_async(void *untypedBaton) {
@@ -998,8 +993,8 @@ void GitSubmodule::Foreach_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();
@@ -1027,7 +1022,7 @@ void GitSubmodule::Foreach_callback_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitSubmodule::Foreach_callback_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitSubmodule::Foreach_callback_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   Foreach_CallbackBaton* baton = static_cast<Foreach_CallbackBaton*>(_baton);
@@ -1068,7 +1063,7 @@ NAN_METHOD(GitSubmodule::HeadId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1083,22 +1078,22 @@ NAN_METHOD(GitSubmodule::HeadId) {
           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));
   }
 }
    
@@ -1111,7 +1106,7 @@ NAN_METHOD(GitSubmodule::Ignore) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1122,11 +1117,11 @@ NAN_METHOD(GitSubmodule::Ignore) {
     );
 
 
-      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));
   }
 }
    
@@ -1139,7 +1134,7 @@ NAN_METHOD(GitSubmodule::IndexId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1154,22 +1149,22 @@ NAN_METHOD(GitSubmodule::IndexId) {
           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));
   }
 }
   
@@ -1182,15 +1177,19 @@ NAN_METHOD(GitSubmodule::Init) {
     return Nan::ThrowError("Number overwrite 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.");
   }
 
-  InitBaton* baton = new InitBaton;
+  InitBaton* baton = new InitBaton();
 
   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->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 // start convert_from_v8 block
   int from_overwrite;
@@ -1198,26 +1197,28 @@ NAN_METHOD(GitSubmodule::Init) {
 // end convert_from_v8 block
           baton->overwrite = from_overwrite;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  InitWorker *worker = new InitWorker(baton, callback);
-
-        worker->SaveToPersistent("submodule", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("overwrite", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  InitWorker *worker = new InitWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitSubmodule>("submodule", info.This());
+           worker->Reference("overwrite", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::InitWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::InitWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-    );
-
     int result = git_submodule_init(
 baton->submodule,baton->overwrite  );
 
@@ -1227,13 +1228,34 @@ baton->submodule,baton->overwrite  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::InitWorker::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("Submodule.init").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 GitSubmodule::InitWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1257,45 +1279,15 @@ void GitSubmodule::InitWorker::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("overwrite"));
       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);
-          }
         }
       }
 
@@ -1324,37 +1316,44 @@ void GitSubmodule::InitWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitSubmodule::Location) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LocationBaton* baton = new LocationBaton;
+  LocationBaton* baton = new LocationBaton();
 
   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->location_status = (unsigned int *)malloc(sizeof(unsigned int ));
         baton->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  LocationWorker *worker = new LocationWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LocationWorker *worker = new LocationWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("submodule", info.This());
+        worker->Reference<GitSubmodule>("submodule", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::LocationWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->location_status
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::LocationWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->location_status
-            ,baton->submodule
-    );
-
     int result = git_submodule_location(
 baton->location_status,baton->submodule  );
 
@@ -1364,17 +1363,38 @@ baton->location_status,baton->submodule  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::LocationWorker::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("Submodule.location").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 GitSubmodule::LocationWorker::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->location_status);
+     v8ConversionSlot = Nan::New<Number>(* baton->location_status);
   // 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
@@ -1398,44 +1418,15 @@ void GitSubmodule::LocationWorker::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);
-          }
         }
       }
 
@@ -1474,15 +1465,19 @@ NAN_METHOD(GitSubmodule::Lookup) {
     return Nan::ThrowError("String name 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.");
   }
 
-  LookupBaton* baton = new LookupBaton;
+  LookupBaton* baton = new LookupBaton();
 
   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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -1503,28 +1498,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  LookupWorker *worker = new LookupWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupWorker *worker = new LookupWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::LookupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::LookupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_submodule_lookup(
 &baton->out,baton->repo,baton->name  );
 
@@ -1534,12 +1530,34 @@ void GitSubmodule::LookupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::LookupWorker::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("Submodule.lookup").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_submodule_free(baton->out);
+
+  delete baton;
 }
 
 void GitSubmodule::LookupWorker::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);
@@ -1551,18 +1569,18 @@ void GitSubmodule::LookupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitSubmodule::New(
+         v8ConversionSlot = GitSubmodule::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
@@ -1586,46 +1604,15 @@ void GitSubmodule::LookupWorker::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"));
-              workerArguments.push(GetFromPersistent("name"));
       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);
-          }
         }
       }
 
@@ -1642,6 +1629,7 @@ void GitSubmodule::LookupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_submodule_free(baton->out);
   }
 
 
@@ -1658,7 +1646,7 @@ NAN_METHOD(GitSubmodule::Name) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1673,17 +1661,17 @@ NAN_METHOD(GitSubmodule::Name) {
           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));
   }
 }
   
@@ -1692,35 +1680,42 @@ NAN_METHOD(GitSubmodule::Name) {
    */
 NAN_METHOD(GitSubmodule::Open) {
 
-  if (info.Length() == 0 || !info[0]->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;
+
         baton->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  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);
 
-        worker->SaveToPersistent("submodule", info.This());
+        worker->Reference<GitSubmodule>("submodule", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::OpenWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::OpenWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-    );
-
     int result = git_submodule_open(
 &baton->repo,baton->submodule  );
 
@@ -1730,25 +1725,47 @@ void GitSubmodule::OpenWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::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("Submodule.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_repository_free(baton->repo);
+
+  delete baton;
 }
 
 void GitSubmodule::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->repo != NULL) {
-        to = GitRepository::New(
+        v8ConversionSlot = GitRepository::New(
         baton->repo,
         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
@@ -1772,44 +1789,15 @@ void GitSubmodule::OpenWorker::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);
-          }
         }
       }
 
@@ -1826,6 +1814,7 @@ void GitSubmodule::OpenWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_repository_free(baton->repo);
   }
 
 
@@ -1842,7 +1831,7 @@ NAN_METHOD(GitSubmodule::Owner) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1857,19 +1846,19 @@ NAN_METHOD(GitSubmodule::Owner) {
           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 = GitRepository::New(
+        v8ConversionSlot = GitRepository::New(
         result,
         true
        );
    }
   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));
   }
 }
    
@@ -1882,7 +1871,7 @@ NAN_METHOD(GitSubmodule::Path) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1897,17 +1886,17 @@ NAN_METHOD(GitSubmodule::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));
   }
 }
    
@@ -1929,7 +1918,7 @@ NAN_METHOD(GitSubmodule::Reload) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -1941,11 +1930,11 @@ NAN_METHOD(GitSubmodule::Reload) {
     );
 
 
-      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));
   }
 }
   
@@ -1959,15 +1948,19 @@ NAN_METHOD(GitSubmodule::RepoInit) {
     return Nan::ThrowError("Number use_gitlink 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.");
   }
 
-  RepoInitBaton* baton = new RepoInitBaton;
+  RepoInitBaton* baton = new RepoInitBaton();
 
   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->sm = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 // start convert_from_v8 block
   int from_use_gitlink;
@@ -1975,26 +1968,28 @@ NAN_METHOD(GitSubmodule::RepoInit) {
 // end convert_from_v8 block
           baton->use_gitlink = from_use_gitlink;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  RepoInitWorker *worker = new RepoInitWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RepoInitWorker *worker = new RepoInitWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("sm", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("use_gitlink", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitSubmodule>("sm", info.This());
+           worker->Reference("use_gitlink", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::RepoInitWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->sm
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::RepoInitWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->sm
-    );
-
     int result = git_submodule_repo_init(
 &baton->out,baton->sm,baton->use_gitlink  );
 
@@ -2004,25 +1999,47 @@ void GitSubmodule::RepoInitWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::RepoInitWorker::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("Submodule.repoInit").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_repository_free(baton->out);
+
+  delete baton;
 }
 
 void GitSubmodule::RepoInitWorker::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 = GitRepository::New(
+        v8ConversionSlot = GitRepository::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
@@ -2046,45 +2063,15 @@ void GitSubmodule::RepoInitWorker::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("use_gitlink"));
       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);
-          }
         }
       }
 
@@ -2101,6 +2088,7 @@ void GitSubmodule::RepoInitWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_repository_free(baton->out);
   }
 
 
@@ -2123,15 +2111,19 @@ NAN_METHOD(GitSubmodule::ResolveUrl) {
     return Nan::ThrowError("String url 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.");
   }
 
-  ResolveUrlBaton* baton = new ResolveUrlBaton;
+  ResolveUrlBaton* baton = new ResolveUrlBaton();
 
   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_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
@@ -2155,29 +2147,30 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->url = from_url;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  ResolveUrlWorker *worker = new ResolveUrlWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ResolveUrlWorker *worker = new ResolveUrlWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("url", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::ResolveUrlWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->repo
+          ,baton->url
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::ResolveUrlWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->repo
-            ,baton->url
-    );
-
     int result = git_submodule_resolve_url(
 baton->out,baton->repo,baton->url  );
 
@@ -2187,22 +2180,45 @@ baton->out,baton->repo,baton->url  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::ResolveUrlWorker::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("Submodule.resolveUrl").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_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitSubmodule::ResolveUrlWorker::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) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   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
@@ -2226,46 +2242,15 @@ void GitSubmodule::ResolveUrlWorker::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"));
-              workerArguments.push(GetFromPersistent("url"));
       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);
-          }
         }
       }
 
@@ -2345,7 +2330,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -2362,11 +2347,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(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));
   }
 }
    
@@ -2415,7 +2400,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -2430,11 +2415,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(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));
   }
 }
   
@@ -2457,15 +2442,19 @@ NAN_METHOD(GitSubmodule::SetIgnore) {
     return Nan::ThrowError("Number ignore is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetIgnoreBaton* baton = new SetIgnoreBaton;
+  SetIgnoreBaton* baton = new SetIgnoreBaton();
 
   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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -2491,30 +2480,30 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->ignore = from_ignore;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  SetIgnoreWorker *worker = new SetIgnoreWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetIgnoreWorker *worker = new SetIgnoreWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("ignore", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("ignore", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::SetIgnoreWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::SetIgnoreWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_submodule_set_ignore(
 baton->repo,baton->name,baton->ignore  );
 
@@ -2524,13 +2513,34 @@ baton->repo,baton->name,baton->ignore  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::SetIgnoreWorker::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("Submodule.setIgnore").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 GitSubmodule::SetIgnoreWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2554,47 +2564,15 @@ void GitSubmodule::SetIgnoreWorker::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"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("ignore"));
       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);
-          }
         }
       }
 
@@ -2637,15 +2615,19 @@ NAN_METHOD(GitSubmodule::SetUpdate) {
     return Nan::ThrowError("Number update is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetUpdateBaton* baton = new SetUpdateBaton;
+  SetUpdateBaton* baton = new SetUpdateBaton();
 
   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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -2671,30 +2653,30 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->update = from_update;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  SetUpdateWorker *worker = new SetUpdateWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetUpdateWorker *worker = new SetUpdateWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("update", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("update", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::SetUpdateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::SetUpdateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_submodule_set_update(
 baton->repo,baton->name,baton->update  );
 
@@ -2704,13 +2686,34 @@ baton->repo,baton->name,baton->update  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::SetUpdateWorker::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("Submodule.setUpdate").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 GitSubmodule::SetUpdateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2734,47 +2737,15 @@ void GitSubmodule::SetUpdateWorker::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"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("update"));
       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);
-          }
         }
       }
 
@@ -2817,15 +2788,19 @@ NAN_METHOD(GitSubmodule::SetUrl) {
     return Nan::ThrowError("String url is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetUrlBaton* baton = new SetUrlBaton;
+  SetUrlBaton* baton = new SetUrlBaton();
 
   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
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -2860,31 +2835,31 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->url = from_url;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  SetUrlWorker *worker = new SetUrlWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetUrlWorker *worker = new SetUrlWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("url", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::SetUrlWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+          ,baton->url
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::SetUrlWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-            ,baton->url
-    );
-
     int result = git_submodule_set_url(
 baton->repo,baton->name,baton->url  );
 
@@ -2894,13 +2869,34 @@ baton->repo,baton->name,baton->url  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::SetUrlWorker::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("Submodule.setUrl").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 GitSubmodule::SetUrlWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2924,47 +2920,15 @@ void GitSubmodule::SetUrlWorker::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"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("url"));
       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);
-          }
         }
       }
 
@@ -3008,15 +2972,19 @@ NAN_METHOD(GitSubmodule::Status) {
     return Nan::ThrowError("Number ignore is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  StatusBaton* baton = new StatusBaton;
+  StatusBaton* baton = new StatusBaton();
 
   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->status = (unsigned int *)malloc(sizeof(unsigned int ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -3043,31 +3011,31 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->ignore = from_ignore;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  StatusWorker *worker = new StatusWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  StatusWorker *worker = new StatusWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("ignore", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("ignore", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::StatusWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->status
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::StatusWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->status
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_submodule_status(
 baton->status,baton->repo,baton->name,baton->ignore  );
 
@@ -3077,17 +3045,38 @@ baton->status,baton->repo,baton->name,baton->ignore  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::StatusWorker::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("Submodule.status").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 GitSubmodule::StatusWorker::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->status);
+     v8ConversionSlot = Nan::New<Number>(* baton->status);
   // 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
@@ -3111,47 +3100,15 @@ void GitSubmodule::StatusWorker::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"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("ignore"));
       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);
-          }
         }
       }
 
@@ -3179,35 +3136,42 @@ void GitSubmodule::StatusWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitSubmodule::Sync) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SyncBaton* baton = new SyncBaton;
+  SyncBaton* baton = new SyncBaton();
 
   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->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  SyncWorker *worker = new SyncWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SyncWorker *worker = new SyncWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("submodule", info.This());
+        worker->Reference<GitSubmodule>("submodule", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitSubmodule::SyncWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+  );
+
+  return lockMaster;
+}
+
 void GitSubmodule::SyncWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-    );
-
     int result = git_submodule_sync(
 baton->submodule  );
 
@@ -3217,13 +3181,34 @@ baton->submodule  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::SyncWorker::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("Submodule.sync").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 GitSubmodule::SyncWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3247,44 +3232,15 @@ void GitSubmodule::SyncWorker::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);
-          }
         }
       }
 
@@ -3318,55 +3274,63 @@ NAN_METHOD(GitSubmodule::Update) {
     return Nan::ThrowError("Number init 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.");
   }
 
-  UpdateBaton* baton = new UpdateBaton;
+  UpdateBaton* baton = new UpdateBaton();
 
   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->submodule = Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue();
 // start convert_from_v8 block
   int from_init;
       from_init = (int)   info[0].As<v8::Number>()->Value();
 // end convert_from_v8 block
           baton->init = from_init;
-// start convert_from_v8 block
-  git_submodule_update_options * from_options = NULL;
-    if (info[1]->IsObject()) {
-from_options = Nan::ObjectWrap::Unwrap<GitSubmoduleUpdateOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_options = 0;
-  }
-// end convert_from_v8 block
-          baton->options = from_options;
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->options = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitSubmoduleUpdateOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["options"] = convertedObject;
+            baton->options = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  UpdateWorker *worker = new UpdateWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  UpdateWorker *worker = new UpdateWorker(baton, callback);
+        worker->Reference<GitSubmodule>("submodule", info.This());
+           worker->Reference("init", info[0]);
+            worker->Reference("options", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        worker->SaveToPersistent("submodule", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("init", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("options", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+nodegit::LockMaster GitSubmodule::UpdateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->submodule
+          ,baton->options
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitSubmodule::UpdateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->submodule
-            ,baton->options
-    );
-
     int result = git_submodule_update(
 baton->submodule,baton->init,baton->options  );
 
@@ -3376,13 +3340,34 @@ baton->submodule,baton->init,baton->options  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitSubmodule::UpdateWorker::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("Submodule.update").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 GitSubmodule::UpdateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3406,46 +3391,15 @@ void GitSubmodule::UpdateWorker::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("init"));
-              workerArguments.push(GetFromPersistent("options"));
       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);
-          }
         }
       }
 
@@ -3478,7 +3432,7 @@ NAN_METHOD(GitSubmodule::UpdateStrategy) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -3489,11 +3443,11 @@ NAN_METHOD(GitSubmodule::UpdateStrategy) {
     );
 
 
-      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));
   }
 }
    
@@ -3506,7 +3460,7 @@ NAN_METHOD(GitSubmodule::Url) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -3521,17 +3475,17 @@ NAN_METHOD(GitSubmodule::Url) {
           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));
   }
 }
    
@@ -3544,7 +3498,7 @@ NAN_METHOD(GitSubmodule::WdId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitSubmodule>(info.This())->GetValue()
@@ -3559,22 +3513,22 @@ NAN_METHOD(GitSubmodule::WdId) {
           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));
   }
 }
     // force base class template instantiation, to make sure we get all the