refactor(HyperVisor,InstanceReturnHandler): use new generic worker

Author: Rush

src/hypervisor.cc

@@ -13,6 +13,7 @@
 #include "network_filter.h"
 #include "interface.h"
 #include "hypervisor.h"
+#include "worker.h"
 
 namespace NLV {
 
@@ -229,64 +230,45 @@ NAN_METHOD(Hypervisor::New)
   return info.GetReturnValue().Set(info.This());
 }
 
-int Hypervisor::ConnectWorker::auth_callback(virConnectCredentialPtr cred,
-                                             unsigned int ncred, void *data)
-{
-  Hypervisor *hypervisor = static_cast<ConnectWorker*>(data)->hypervisor_;
-
-  for (unsigned int i = 0; i < ncred; ++i) {
-    switch (cred[i].type) {
-    case VIR_CRED_AUTHNAME:
-      cred[i].result = strdup(hypervisor->username_.c_str());
-      if (cred[i].result == NULL)
-        return -1;
-      cred[i].resultlen = strlen(cred[i].result);
-      break;
-
-    case VIR_CRED_PASSPHRASE:
-      cred[i].result = strdup(hypervisor->password_.c_str());
-      if (cred[i].result == NULL)
-          return -1;
-      cred[i].resultlen = strlen(cred[i].result);
-      break;
-    }
-  }
-
-  return 0;
-}
-
 NAN_METHOD(Hypervisor::Connect)
 {
-  Nan::HandleScope scope;
-  if (info.Length() == 1 && !info[0]->IsFunction()) {
-    Nan::ThrowTypeError("You must specify a function as first argument");
-    return;
-  }
-
-  Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());
-  Hypervisor *hv = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new ConnectWorker(callback, hv));
-  return;
-}
-
-NLV_WORKER_EXECUTE(Hypervisor, Connect)
-{
-  static int supported_cred_types[] = {
-    VIR_CRED_AUTHNAME,
-    VIR_CRED_PASSPHRASE,
-  };
-
-  virConnectAuth auth;
-  auth.credtype = supported_cred_types;
-  auth.ncredtype = sizeof(supported_cred_types) / sizeof(int);
-  auth.cb = ConnectWorker::auth_callback;
-  auth.cbdata = this;
-
-  hypervisor_->handle_ =
-    virConnectOpenAuth((const char*) hypervisor_->uri_.c_str(), &auth,
-                       hypervisor_->readOnly_ ? VIR_CONNECT_RO : 0);
-  if (hypervisor_->handle_ == NULL)
-    SetVirError(virSaveLastError());
+  Hypervisor *hv = Hypervisor::Unwrap(info.This());
+  std::string uri = hv->uri_;
+  Worker::RunAsync(info, [=](Worker::SetOnFinishedHandler onFinished ) {
+    static int supported_cred_types[] = {
+      VIR_CRED_AUTHNAME,
+      VIR_CRED_PASSPHRASE,
+    };
+
+    virConnectAuth auth;
+    auth.credtype = supported_cred_types;
+    auth.ncredtype = sizeof(supported_cred_types) / sizeof(int);
+    auth.cb = [](virConnectCredentialPtr cred, unsigned int ncred, void *data) {
+      Hypervisor *hypervisor = static_cast<Hypervisor*>(data);
+      for (unsigned int i = 0; i < ncred; ++i) {
+        switch (cred[i].type) {
+        case VIR_CRED_AUTHNAME:
+          cred[i].result = strdup(hypervisor->username_.c_str());
+          if (cred[i].result == NULL)
+            return -1;
+          cred[i].resultlen = strlen(cred[i].result);
+          break;
+
+        case VIR_CRED_PASSPHRASE:
+          cred[i].result = strdup(hypervisor->password_.c_str());
+          if (cred[i].result == NULL)
+              return -1;
+          cred[i].resultlen = strlen(cred[i].result);
+          break;
+        }
+      }
+      return 0;
+    };
+    auth.cbdata = hv;
+    hv->handle_ = virConnectOpenAuth(uri.c_str(), &auth,
+                       hv->readOnly_ ? VIR_CONNECT_RO : 0);
+    return onFinished(PrimitiveReturnHandler(true));
+  });
 }
 
 NAN_METHOD(Hypervisor::Disconnect)

src/hypervisor.h

@@ -96,18 +96,6 @@ class Hypervisor : public NLVObject<Hypervisor, virConnectPtr, HypervisorCleanup
   // static NAN_METHOD(FindStoragePoolSources);
 
 private:
-  // ACTION WORKERS
-  class ConnectWorker : public NLVAsyncWorker<virConnectPtr> {
-  public:
-    ConnectWorker(Nan::Callback *callback, Hypervisor *hypervisor)
-      : NLVAsyncWorker(callback, NULL), hypervisor_(hypervisor) {}
-
-    void Execute();
-    static int auth_callback(virConnectCredentialPtr cred, unsigned int ncred, void *data);
-  private:
-    Hypervisor *hypervisor_;
-  };
-
   class DisconnectWorker : public NLVAsyncWorker<virConnectPtr> {
   public:
     DisconnectWorker(Nan::Callback *callback, Hypervisor *hypervisor)

src/nlv_object.h

@@ -54,6 +54,8 @@ class NLVObjectBase : public Nan::ObjectWrap
   virtual void ClearHandle() = 0;
   virtual void ClearChildren() = 0;
   virtual void SetParentReference(NLVObjectBasePtr *parentReference) = 0;
+
+  std::vector<NLVObjectBasePtr*> children_;
 };
 
 template <typename ParentClass, typename HandleType, typename CleanupHandler>
@@ -99,6 +101,7 @@ class NLVObject : public NLVObjectBase
 
     return ObjectWrap::Unwrap<ParentClass>(val);
   }
+
   NAN_INLINE static ParentClass* Unwrap(v8::Local<v8::Value> val) {
     if(!val->IsObject()) {
       char error[128];
@@ -146,8 +149,6 @@ class NLVObject : public NLVObjectBase
     parentReference_ = parentReference;
   }
 
-  std::vector<NLVObjectBasePtr*> children_;
-
 protected:
   HandleType handle_;
   NLVObjectBasePtr* parentReference_;
@@ -181,5 +182,4 @@ NAN_INLINE unsigned int GetFlags(v8::Local<v8::Value> val) {
 
 };
 
-
 #endif  // NLV_OBJECT_H

src/storage_pool.cc

@@ -115,7 +115,7 @@ NAN_METHOD(StoragePool::LookupByVolume)
       return virSaveLastError();
     }
 
-    return onFinished(InstanceReturnHandler<Hypervisor, StoragePool>(storagePool));
+    return onFinished(InstanceReturnHandler<StoragePool>(storagePool));
   });
 }
 
@@ -136,7 +136,7 @@ NAN_METHOD(StoragePool::Create)
     if (lookupHandle == NULL) {
       return virSaveLastError();
     }
-    return onFinished(InstanceReturnHandler<Hypervisor, StoragePool>(lookupHandle));
+    return onFinished(InstanceReturnHandler<StoragePool>(lookupHandle));
   });
 }
 

src/storage_volume.cc

@@ -47,7 +47,6 @@ NAN_METHOD(StorageVolume::Create)
     Nan::ThrowTypeError("You must specify a string and callback");
     return;
   }
-
   auto sp = StoragePool::UnwrapHandle(info.This());
   std::string xmlData(*Nan::Utf8String(info[0]->ToString()));
   unsigned int flags = GetFlags(info[1]);
@@ -57,7 +56,7 @@ NAN_METHOD(StorageVolume::Create)
     if (handle == NULL) {
       return virSaveLastError();
     }
-    return onFinished(InstanceReturnHandler<StoragePool, StorageVolume>(handle));
+    return onFinished(InstanceReturnHandler<StorageVolume>(handle));
   });
 }
 

src/worker.h

@@ -14,7 +14,8 @@ namespace NLV {
     OnFinishedHandler on_finished_handler;
 
     explicit Worker(Nan::Callback *callback, ExecuteHandler handler)
-      : NLVAsyncWorkerBase(callback), execute_handler(handler) { };
+      : NLVAsyncWorkerBase(callback), execute_handler(handler)
+    { };
 
     void HandleOKCallback() {
       on_finished_handler(this);
@@ -30,7 +31,8 @@ namespace NLV {
         on_finished_handler = handler;
         return nullptr;
       });
-      if(error) {
+
+      if (error) {
         SetVirError(error);
       }
     }
@@ -47,25 +49,26 @@ namespace NLV {
     };
   }
 
-  template<class ParentClass, class T, class Y>
+  template<class T, class Y>
   Worker::OnFinishedHandler InstanceReturnHandler(Y val) {
     return [=](Worker* worker) {
       Nan::HandleScope scope;
       Nan::TryCatch try_catch;
 
       Local<Object> childObject = T::NewInstance(val);
       Local<Value> parentObject = worker->GetFromPersistent("parent");
+      T* child = T::Unwrap(childObject);
+      NLVObjectBasePtr* childPtr = new NLVObjectBasePtr(child);
       if (parentObject->IsObject()) {
         childObject->Set(Nan::New("_parent").ToLocalChecked(), parentObject);
+
+        auto parent = Nan::ObjectWrap::Unwrap<NLVObjectBase>(parentObject->ToObject());
+        if (parent) {
+          parent->children_.push_back(childPtr);
+        }
       }
 
-      T *child = Nan::ObjectWrap::Unwrap<T>(childObject);
-      NLVObjectBasePtr *childPtr = new NLVObjectBasePtr(child);
       child->SetParentReference(childPtr);
-      auto parent = ParentClass::Unwrap(parentObject);
-      if (parent) {
-        parent->children_.push_back(childPtr);
-      }
 
       if (try_catch.HasCaught()) {
         v8::Local<v8::Value> argv[] = { try_catch.Exception() };