Add context object to pass data from JavaScript to PHP.

Author: cscott

lib/index.js

@@ -25,7 +25,8 @@ exports.request = function(options, cb) {
 		source = 'require '+addslashes(options.file)+';';
 	}
 	var stream = options.stream || process.stdout;
-	return request(source, stream).tap(function() {
+	var context = options.context;
+	return request(source, stream, context).tap(function() {
 		// ensure the stream is flushed before promise is resolved
 		return new Promise(function(resolve, reject) {
 			stream.write(new Buffer(0), resolve);

src/asyncmessageworker.h

@@ -1,8 +1,11 @@
 #ifndef ASYNCMESSAGEWORKER_H
 #define ASYNCMESSAGEWORKER_H
 #include <nan.h>
+#include <cassert>
 #include <list>
+#include <unordered_map>
 #include "messages.h"
+#include "node_php_jsobject_class.h"
 
 namespace node_php_embed {
 
@@ -11,42 +14,117 @@ namespace node_php_embed {
  */
 /* abstract */ class AsyncMessageWorker : public Nan::AsyncWorker {
  public:
-  explicit AsyncMessageWorker(Nan::Callback *callback_)
-      : AsyncWorker(callback_), asyncdata_(), waitingForLock_(false),
-        nextId_(0) {
+  class MessageChannel;
+  explicit AsyncMessageWorker(Nan::Callback *callback)
+      : AsyncWorker(callback), asyncdata_(), waitingForLock_(false),
+        phpObjToId_(), phpObjList_(),
+        // id #0 is reserved for "invalid object"
+        nextId_(1) {
     async = new uv_async_t;
     uv_async_init(uv_default_loop(), async, AsyncMessage_);
     async->data = this;
 
-    uv_mutex_init(&async_lock);
+    uv_mutex_init(&async_lock_);
+    uv_mutex_init(&id_lock_);
 
-    objToId_.Reset(v8::NativeWeakMap::New(v8::Isolate::GetCurrent()));
+    jsObjToId_.Reset(v8::NativeWeakMap::New(v8::Isolate::GetCurrent()));
   }
 
   virtual ~AsyncMessageWorker() {
-    uv_mutex_destroy(&async_lock);
+    // invalidate any lingering js wrapper objects to this request
+    ClearAllJsIds();
+    uv_mutex_destroy(&async_lock_);
+    uv_mutex_destroy(&id_lock_);
     // can't safely delete entries from asyncdata_, it better be empty.
-    objToId_.Reset();
+    jsObjToId_.Reset();
   }
 
-  // Map Js object to an index
-  uint32_t IdForJsObj(const v8::Local<v8::Object> o) {
+  // Map Js object to an index (JS thread only)
+  objid_t IdForJsObj(const v8::Local<v8::Object> o) {
       // Have we already mapped this?
       Nan::HandleScope scope;
-      v8::Local<v8::NativeWeakMap> objToId = Nan::New(objToId_);
-      if (objToId->Has(o)) {
-          return Nan::To<uint32_t>(objToId->Get(o)).FromJust();
+      v8::Local<v8::NativeWeakMap> jsObjToId = Nan::New(jsObjToId_);
+      if (jsObjToId->Has(o)) {
+          return Nan::To<objid_t>(jsObjToId->Get(o)).FromJust();
+      }
+      uv_mutex_lock(&id_lock_);
+      objid_t id = (nextId_++);
+      uv_mutex_unlock(&id_lock_);
+      jsObjToId->Set(o, Nan::New(id));
+      SaveToPersistent(id, o);
+      return id;
+  }
+  v8::Local<v8::Object> JsObjForId(objid_t id) {
+      Nan::EscapableHandleScope scope;
+      // XXX if doesn't exist, then make a wrapper (and store it in the maps)
+      return scope.Escape(Nan::To<v8::Object>(
+        GetFromPersistent(id)
+      ).ToLocalChecked());
+  }
+  // Map PHP object to an index (PHP thread only)
+  objid_t IdForPhpObj(zval *z) {
+      if (phpObjToId_.count(z)) {
+          return phpObjToId_.at(z);
+      }
+      uv_mutex_lock(&id_lock_);
+      objid_t id = (nextId_++);
+      uv_mutex_unlock(&id_lock_);
+      Z_ADDREF_P(z);
+      if (id >= phpObjList_.size()) { phpObjList_.resize(id+1); }
+      phpObjList_[id] = z;
+      phpObjToId_[z] = id;
+      return id;
+  }
+  // returned value is owned by objectmapper, caller should not release it.
+  zval * PhpObjForId(MessageChannel *channel, objid_t id TSRMLS_DC) {
+      if (id >= phpObjList_.size()) { phpObjList_.resize(id+1); }
+      ZVal z(phpObjList_[id] ZEND_FILE_LINE_CC);
+      if (z.IsNull()) {
+          node_php_jsobject_create(z.Ptr(), channel, id TSRMLS_CC);
+          phpObjList_[id] = z.Ptr();
+          phpObjToId_[z.Ptr()] = id;
+          // one excess reference: owned by objectmapper
+          return z.Escape();
+      }
+      // don't increment reference
+      return z.Ptr();
+  }
+  // Free PHP references associated with an id (from PHP thread)
+  void ClearPhpId(objid_t id) {
+      zval *z = (id < phpObjList_.size()) ? phpObjList_[id] : NULL;
+      if (z) {
+          phpObjList_[id] = NULL;
+          phpObjToId_.erase(z);
+          zval_ptr_dtor(&z);
+      }
+  }
+  void ClearAllPhpIds() {
+      for (objid_t id = 1; id < nextId_; id++) {
+          ClearPhpId(id);
+      }
+  }
+  // Free JS references associated with an id (from JS thread)
+  void ClearJsId(objid_t id) {
+      Nan::HandleScope scope;
+      Nan::MaybeLocal<v8::Object> o =
+          Nan::To<v8::Object>(GetFromPersistent(id));
+      if (o.IsEmpty()) { return; }
+      // XXX depending on o's type, set its "is request valid" flag to false
+      // since there might be other references to this object.
+      v8::Local<v8::NativeWeakMap> jsObjToId = Nan::New(jsObjToId_);
+      jsObjToId->Delete(o.ToLocalChecked());
+      SaveToPersistent(id, Nan::Undefined());
+  }
+  void ClearAllJsIds() {
+      for (objid_t id = 1; id < nextId_; id++) {
+          ClearJsId(id);
       }
-      uint32_t r = (nextId_++);
-      objToId->Set(o, Nan::New(r));
-      SaveToPersistent(r, o);
-      return r;
   }
 
   void WorkComplete() {
-    uv_mutex_lock(&async_lock);
+    uv_mutex_lock(&async_lock_);
     waitingForLock_ = !asyncdata_.empty();
-    uv_mutex_unlock(&async_lock);
+    uv_mutex_unlock(&async_lock_);
 
     if (!waitingForLock_) {
       Nan::AsyncWorker::WorkComplete();
@@ -62,10 +140,10 @@ namespace node_php_embed {
     std::list<MessageToJs *> newData;
     bool waiting;
 
-    uv_mutex_lock(&async_lock);
+    uv_mutex_lock(&async_lock_);
     newData.splice(newData.begin(), asyncdata_);
     waiting = waitingForLock_;
-    uv_mutex_unlock(&async_lock);
+    uv_mutex_unlock(&async_lock_);
 
     for (std::list<MessageToJs *>::iterator it = newData.begin();
          it != newData.end(); it++) {
@@ -91,20 +169,17 @@ namespace node_php_embed {
     AsyncMessageWorker *GetWorker() const {
       return that_;
     }
-    virtual uint32_t IdForJsObj(const v8::Local<v8::Object> o) {
+    virtual objid_t IdForJsObj(const v8::Local<v8::Object> o) {
         return that_->IdForJsObj(o);
     }
-    virtual v8::Local<v8::Object> GetJs(uint32_t id) {
-        Nan::EscapableHandleScope scope;
-        return scope.Escape(Nan::To<v8::Object>(
-            that_->GetFromPersistent(id)
-        ).ToLocalChecked());
+    virtual v8::Local<v8::Object> JsObjForId(objid_t id) {
+        return that_->JsObjForId(id);
     }
-    virtual uint32_t IdForPhpObj(const zval *o) {
-        return 0; // XXX
+    virtual objid_t IdForPhpObj(zval *o) {
+        return that_->IdForPhpObj(o);
     }
-    virtual void GetPhp(uint32_t id, zval *return_value TSRMLS_DC) {
-        // XXX use GetFromPersistent, and then unwrap v8::External?
+    virtual zval * PhpObjForId(objid_t id TSRMLS_DC) {
+        return that_->PhpObjForId(this, id TSRMLS_CC);
     }
   private:
     explicit MessageChannel(AsyncMessageWorker* that) : that_(that) {}
@@ -123,16 +198,37 @@ namespace node_php_embed {
      * WorkComplete */
   }
 
+  // Limited ObjectMapper for use during subclass initialization.
+ protected:
+  class JsOnlyMapper : public ObjectMapper {
+  public:
+      JsOnlyMapper(AsyncMessageWorker *worker) : worker_(worker) { }
+      virtual objid_t IdForJsObj(const v8::Local<v8::Object> o) {
+          return worker_->IdForJsObj(o);
+      }
+      virtual v8::Local<v8::Object> JsObjForId(objid_t id) {
+          assert(false); return Nan::New<v8::Object>();
+      }
+      virtual objid_t IdForPhpObj(zval *o) {
+          assert(false); return 0;
+      }
+      virtual zval * PhpObjForId(objid_t id TSRMLS_DC) {
+          assert(false); return NULL;
+      }
+  private:
+      AsyncMessageWorker *worker_;
+  };
+
  private:
   void Execute() /*final override*/ {
     MessageChannel messageChannel(this);
     Execute(messageChannel);
   }
 
   void SendMessage_(MessageToJs *b) {
-    uv_mutex_lock(&async_lock);
+    uv_mutex_lock(&async_lock_);
     asyncdata_.push_back(b);
-    uv_mutex_unlock(&async_lock);
+    uv_mutex_unlock(&async_lock_);
 
     uv_async_send(async);
   }
@@ -151,12 +247,19 @@ namespace node_php_embed {
   }
 
   uv_async_t *async;
-  uv_mutex_t async_lock;
+  uv_mutex_t async_lock_;
   std::list<MessageToJs *> asyncdata_;
   bool waitingForLock_;
   // Js Object mapping (along with GetFromPersistent/etc)
-  Nan::Persistent<v8::NativeWeakMap> objToId_;
-  uint32_t nextId_;
+  // Read/writable only from Js thread
+  Nan::Persistent<v8::NativeWeakMap> jsObjToId_;
+  // PHP Object mapping
+  // Read/writable only from PHP thread
+  std::unordered_map<zval*,objid_t> phpObjToId_;
+  std::vector<zval*> phpObjList_;
+  // Ids are allocated from both threads, so mutex is required
+  uv_mutex_t id_lock_;
+  objid_t nextId_;
 };
 
 }

src/messages.h

@@ -106,9 +106,8 @@ class JsInvokeMethodMsg : public MessageToJs {
  public:
     JsInvokeMethodMsg(ObjectMapper *m, zval *obj, zval *name, int argc, zval **argv)
         : MessageToJs(m), obj_(m, obj), name_(m, name), argc_(argc), argv_(Value::NewArray(m, argc, argv)) { }
-    JsInvokeMethodMsg(ObjectMapper *m, uint32_t objId, const char *name, int argc, zval **argv)
-        : MessageToJs(m), obj_(), name_(), argc_(argc), argv_(Value::NewArray(m, argc, argv)) {
-        obj_.SetJsObject(objId);
+    JsInvokeMethodMsg(ObjectMapper *m, zval *obj, const char *name, int argc, zval **argv)
+        : MessageToJs(m), obj_(m, obj), name_(), argc_(argc), argv_(Value::NewArray(m, argc, argv)) {
         name_.SetOwnedString(name, strlen(name));
     }
     virtual ~JsInvokeMethodMsg() { delete[] argv_; }
@@ -149,12 +148,12 @@ class PhpGetPropertyMsg : public MessageToPhp {
         : MessageToPhp(m), obj_(m, obj), name_(m, name) { }
  protected:
     virtual void InPhp(ObjectMapper *m TSRMLS_DC) {
-        ZVal obj, name;
+        ZVal obj(ZEND_FILE_LINE_C), name(ZEND_FILE_LINE_C);
         zval *r;
         zend_class_entry *ce;
         zend_property_info *property_info;
 
-        obj_.ToPhp(m, *obj TSRMLS_CC); name_.ToPhp(m, *name TSRMLS_CC);
+        obj_.ToPhp(m, obj TSRMLS_CC); name_.ToPhp(m, name TSRMLS_CC);
         if (!(obj.IsObject() && name.IsString())) {
             retval_.SetNull();
             return;