Esempio n. 1
0
ServiceRef::~ServiceRef() {
    // First, dispose the serice ref. This cancels all asynchronous operations.
    if (ref_) {
        DNSServiceRefDeallocate(ref_);
    }
    // Then release the js objects.
    if ( ! callback_.IsEmpty()) {
        NanDisposePersistent(callback_);
    }
    if ( ! context_.IsEmpty()) {
        NanDisposePersistent(context_);
    }
}
void PersistentDisposeContext::CallDisposeOnV8Thread() {
    DBG("PersistentDisposeContext::CallDisposeOnV8Thread");

    Persistent<Value>* handle = (Persistent<Value>*)ptr.ToPointer();
    NanDisposePersistent(*handle);
    delete handle;
}
Esempio n. 3
0
 ~GetDataOperation() {
     EOS_DEBUG_METHOD();
     if (!bufferHandle_.IsEmpty()) {
         EOS_DEBUG(L"Warning! Buffer handle not released by GetDataOperation. (Memory held onto for longer than needed.)\n");
         NanDisposePersistent(bufferHandle_);
     }
 }
Esempio n. 4
0
void
ServiceRef::SetCallback(v8::Handle<v8::Function> callback) {
  if ( ! callback_.IsEmpty()) {
    NanDisposePersistent(callback_);
  }
  NanAssignPersistent(callback_, callback);
}
Esempio n. 5
0
void
ServiceRef::SetContext(v8::Handle<v8::Value> context) {
  if ( ! context_.IsEmpty()) {
    NanDisposePersistent(context_);
  }
  NanAssignPersistent(context_, context);
}
Esempio n. 6
0
void EIO_AfterClose(uv_work_t* req) {
  NanScope();

  CloseBaton* data = static_cast<CloseBaton*>(req->data);

  v8::Handle<v8::Value> argv[1];
  if(data->errorString[0]) {
    argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString));
  } else {
    argv[0] = NanUndefined();

    // We don't have an error, so clean up the write queue for that fd

    _WriteQueue *q = qForFD(data->fd);
    if (q) {
      q->lock();
      QueuedWrite &write_queue = q->get();
      while (!write_queue.empty()) {
        QueuedWrite *del_q = write_queue.next;
        NanDisposePersistent(del_q->baton->buffer);
        del_q->remove();
      }
      q->unlock();

      deleteQForFD(data->fd);
    }

  }
  data->callback->Call(1, argv);

  delete data->callback;
  delete data;
  delete req;
}
void Grid::EIO_AfterEncode(uv_work_t* req)
{
    NanScope();

    encode_grid_baton_t *closure = static_cast<encode_grid_baton_t *>(req->data);


    if (closure->error) 
    {
        // There is no known ways to throw errors in the processing prior
        // so simply removing the following from coverage
        /* LCOV_EXCL_START */
        Local<Value> argv[1] = { NanError(closure->error_name.c_str()) };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
        /* LCOV_EXCL_END */
    } 
    else 
    {

        // convert key order to proper javascript array
        Local<Array> keys_a = NanNew<Array>(closure->key_order.size());
        std::vector<std::string>::iterator it;
        unsigned int i;
        for (it = closure->key_order.begin(), i = 0; it < closure->key_order.end(); ++it, ++i)
        {
            keys_a->Set(i, NanNew((*it).c_str()));
        }

        mapnik::grid const& grid_type = *closure->g->get();
        // gather feature data
        Local<Object> feature_data = NanNew<Object>();
        if (closure->add_features) {
            node_mapnik::write_features<mapnik::grid>(grid_type,
                                                      feature_data,
                                                      closure->key_order);
        }

        // Create the return hash.
        Local<Object> json = NanNew<Object>();
        Local<Array> grid_array = NanNew<Array>(closure->lines.size());
        unsigned array_size = std::ceil(grid_type.width()/static_cast<float>(closure->resolution));
        for (unsigned j=0;j<closure->lines.size();++j)
        {
            node_mapnik::grid_line_type const & line = closure->lines[j];
            grid_array->Set(j, NanNew<String>(line.get(),array_size));
        }
        json->Set(NanNew("grid"), grid_array);
        json->Set(NanNew("keys"), keys_a);
        json->Set(NanNew("data"), feature_data);

        Local<Value> argv[2] = { NanNull(), NanNew(json) };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 2, argv);
    }

    closure->g->Unref();
    NanDisposePersistent(closure->cb);
    delete closure;
}
Esempio n. 8
0
        // Any new return statements added here should call MakeWeak() on bufferHandle_,
        // if it is not empty.
        void CallbackOverride(SQLRETURN ret) {
            EOS_DEBUG_METHOD();

            if (!SQL_SUCCEEDED(ret) && ret != SQL_NO_DATA) {
                if (!bufferHandle_.IsEmpty())
                    NanDisposePersistent(bufferHandle_);
                return CallbackErrorOverride(ret);
            }

            EOS_DEBUG(L"Final Result: %hi\n", ret);

            Handle<Value> argv[4];

            argv[0] = NanUndefined();
            if (totalLength_ != SQL_NO_TOTAL)
                argv[2] = NanNew<Number>(totalLength_);
            else
                argv[2] = NanUndefined();
            argv[3] = NanNew<Boolean>(totalLength_ > bufferLength_ || (totalLength_ == SQL_NO_TOTAL && ret == SQL_SUCCESS_WITH_INFO));

            if (ret == SQL_NO_DATA)
                argv[1] = NanUndefined();
            else if (totalLength_ == SQL_NULL_DATA)
                argv[1] = NanNull();
            else if (raw_) {
                assert(!bufferHandle_.IsEmpty());
                argv[1] = NanNew(bufferHandle_);
            } else if (cType_ == SQL_C_BINARY) {
                if (totalLength_ >= bufferLength_) 
                    argv[1] = NanNew(bufferHandle_);
                else
                    argv[1] = JSBuffer::Slice(NanNew(bufferHandle_), 0, totalLength_);
            } else {
                argv[1] = Eos::ConvertToJS(buffer_, totalLength_, bufferLength_, cType_);
                if (argv[1]->IsUndefined())
                    argv[0] = OdbcError("Unable to interpret contents of result buffer");
            }

            // Can we Dispose() things that JS-land is referencing? We'll soon find out!
            if (!bufferHandle_.IsEmpty())
                NanDisposePersistent(bufferHandle_);
            
            MakeCallback(argv);
        }
void ClrFuncInvokeContext::DisposeCallback()
{
    if (this->callback)
    {
        DBG("ClrFuncInvokeContext::DisposeCallback");
        NanDisposePersistent(*(this->callback));
        delete this->callback;
        this->callback = NULL;        
    }
}
Esempio n. 10
0
void EIO_AfterWrite(uv_work_t* req) {
  NanScope();

  QueuedWrite* queuedWrite = static_cast<QueuedWrite*>(req->data);
  WriteBaton* data = static_cast<WriteBaton*>(queuedWrite->baton);

  v8::Handle<v8::Value> argv[2];
  if(data->errorString[0]) {
    argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString));
    argv[1] = NanUndefined();
  } else {
    argv[0] = NanUndefined();
    argv[1] = NanNew<v8::Int32>(data->result);
  }
  data->callback->Call(2, argv);

  if (data->offset < data->bufferLength && !data->errorString[0]) {
    // We're not done with this baton, so throw it right back onto the queue.
	  // Don't re-push the write in the event loop if there was an error; because same error could occur again!
    // TODO: Add a uv_poll here for unix...
    //fprintf(stderr, "Write again...\n");
    uv_queue_work(uv_default_loop(), req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite);
    return;
  }

  int fd = data->fd;
  _WriteQueue *q = qForFD(fd);
  if(!q) {
    NanThrowTypeError("There's no write queue for that file descriptor (after write)!");
    return;
  }

  q->lock();
  QueuedWrite &write_queue = q->get();

  // remove this one from the list
  queuedWrite->remove();

  // If there are any left, start a new thread to write the next one.
  if (!write_queue.empty()) {
    // Always pull the next work item from the head of the queue
    QueuedWrite* nextQueuedWrite = write_queue.next;
    uv_queue_work(uv_default_loop(), &nextQueuedWrite->req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite);
  }
  q->unlock();

  NanDisposePersistent(data->buffer);
  delete data->callback;
  delete data;
  delete queuedWrite;
}
Esempio n. 11
0
/*
   DESCRIPTION
     Destructor for the Oracledb class.
 */
Oracledb::~Oracledb()
{
  if ( fetchAsStringTypes_ )
  {
    free ( fetchAsStringTypes_ );
    fetchAsStringTypes_ = NULL ;
    fetchAsStringTypesCount_ = 0;
  }

  if (this->dpienv_)
  {
    dpienv_->terminate();
  }

  NanDisposePersistent(jsOracledb);
}
void NodeFileSource::notify(mbgl::Request *req, const std::shared_ptr<const mbgl::Response>& response) {
    // First, remove the request, since it might be destructed at any point now.
    auto it = pending.find(req);
    if (it != pending.end()) {
#if (NODE_MODULE_VERSION <= NODE_0_10_MODULE_VERSION)
        NanDisposePersistent(it->second);
#endif
        pending.erase(it);

        // Make sure the the loop can exit when there are no pending requests.
        if (pending.empty()) {
            queue->unref();
        }
    }

    req->notify(response);
}
Esempio n. 13
0
void Grid::EIO_AfterClear(uv_work_t* req)
{
    NanScope();
    clear_grid_baton_t *closure = static_cast<clear_grid_baton_t *>(req->data);
    if (closure->error)
    {
        Local<Value> argv[1] = { NanError(closure->error_name.c_str()) };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
    }
    else
    {
        Local<Value> argv[2] = { NanNull() };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
    }
    closure->g->Unref();
    NanDisposePersistent(closure->cb);
    delete closure;
}
Esempio n. 14
0
void EIO_AfterWrite(uv_work_t* req) {
  NanScope();

  QueuedWrite* queuedWrite = static_cast<QueuedWrite*>(req->data);
  WriteBaton* data = static_cast<WriteBaton*>(queuedWrite->baton);

  v8::Handle<v8::Value> argv[2];
  if(data->errorString[0]) {
    argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString));
    argv[1] = NanUndefined();
  } else {
    argv[0] = NanUndefined();
    argv[1] = NanNew<v8::Int32>(data->result);
  }
  data->callback->Call(2, argv);

  if (data->offset < data->bufferLength && !data->errorString[0]) {
    // We're not done with this baton, so throw it right back onto the queue.
	  // Don't re-push the write in the event loop if there was an error; because same error could occur again!
    // TODO: Add a uv_poll here for unix...
    uv_queue_work(uv_default_loop(), req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite);
    return;
  }

  uv_mutex_lock(&write_queue_mutex);
  QUEUE_REMOVE(&queuedWrite->queue);

  if (!QUEUE_EMPTY(&write_queue)) {
    // Always pull the next work item from the head of the queue
    QUEUE* head = QUEUE_HEAD(&write_queue);
    QueuedWrite* nextQueuedWrite = QUEUE_DATA(head, QueuedWrite, queue);
    uv_queue_work(uv_default_loop(), &nextQueuedWrite->req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite);
  }
  uv_mutex_unlock(&write_queue_mutex);

  NanDisposePersistent(data->buffer);
  delete data->callback;
  delete data;
  delete queuedWrite;
}
void NodeFileSource::processCancel(mbgl::Request *req) {
    NanScope();

    auto it = pending.find(req);
    if (it == pending.end()) {
        // The response callback was already fired. There is no point in calling the cancelation
        // callback because the request is already completed.
    } else {
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
        auto requestHandle = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), it->second);
#else
        auto requestHandle = NanNew<v8::Object>(it->second);
#endif

        // Dispose and remove the persistent handle
#if (NODE_MODULE_VERSION <= NODE_0_10_MODULE_VERSION)
        NanDisposePersistent(it->second);
#endif
        pending.erase(it);

        // Make sure the the loop can exit when there are no pending requests.
        if (pending.empty()) {
            queue->unref();
        }

        auto handle = NanObjectWrapHandle(this);
        if (handle->Has(NanNew("cancel"))) {
            v8::Local<v8::Value> argv[] = { requestHandle };
            NanMakeCallback(handle, NanNew("cancel"), 1, argv);
        }

        // Set the request handle in the request wrapper handle to null
        ObjectWrap::Unwrap<NodeRequest>(requestHandle)->cancel();
    }

    // Finally, destruct the request object
    req->destruct();
}
Esempio n. 16
0
CoreClrFuncInvokeContext::~CoreClrFuncInvokeContext()
{
	DBG("CoreClrFuncInvokeContext::~CoreClrFuncInvokeContext");

    if (this->callback)
    {
        NanDisposePersistent(*(this->callback));
        delete this->callback;
        this->callback = NULL;
    }

    if (this->task)
    {
    	CoreClrEmbedding::FreeHandle(this->task);
    	this->task = NULL;
    }

    if (this->resultData)
    {
    	CoreClrEmbedding::FreeMarshalData(this->resultData, this->resultType);
    	this->resultData = NULL;
    }
}
void Grid::EIO_AfterClear(uv_work_t* req)
{
    NanScope();
    clear_grid_baton_t *closure = static_cast<clear_grid_baton_t *>(req->data);
    if (closure->error)
    {
        // There seems to be no possible way for the exception to be thrown in the previous 
        // process and therefore not possible to have an error here so removing it from code
        // coverage
        /* LCOV_EXCL_START */
        Local<Value> argv[1] = { NanError(closure->error_name.c_str()) };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
        /* LCOV_EXCL_END */
    }
    else
    {
        Local<Value> argv[2] = { NanNull(), NanObjectWrapHandle(closure->g) };
        NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 2, argv);
    }
    closure->g->Unref();
    NanDisposePersistent(closure->cb);
    delete closure;
}
Esempio n. 18
0
NodejsFunc::~NodejsFunc() 
{
    DBG("NodejsFunc::~NodejsFunc");
    NanDisposePersistent(*(this->Func));
    delete this->Func;
}
Esempio n. 19
0
 virtual ~BufferImageSource()
 {
     NanDisposePersistent(mImageBuffer);
 }
void NodeFileSource::processCancel(const mbgl::Resource& resource) {
    NanScope();

    auto it = pending.find(resource);
    if (it == pending.end()) {
        // The response callback was already fired. There is no point in calling the cancelation
        // callback because the request is already completed.
    } else {
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
        auto requestHandle = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), it->second);
        it->second.Reset();
#else
        auto requestHandle = NanNew<v8::Object>(it->second);
        NanDisposePersistent(it->second);
#endif
        pending.erase(it);

        // Make sure the the loop can exit when there are no pending requests.
        if (pending.empty()) {
            queue->unref();
        }

#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
        auto optionsObject = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), options);
        if (optionsObject->Has(NanNew("cancel"))) {
            auto cancelFunction = optionsObject->Get(NanNew("cancel")).As<v8::Function>();
#else
        if (options->Has(NanNew("cancel"))) {
            auto cancelFunction = options->Get(NanNew("cancel")).As<v8::Function>();
#endif
            v8::Local<v8::Value> argv[] = { requestHandle };
            NanMakeCallback(NanGetCurrentContext()->Global(), cancelFunction, 1, argv);
        }

        // Set the request handle in the request wrapper handle to null
        node::ObjectWrap::Unwrap<NodeRequest>(requestHandle)->cancel();
    }
}

void NodeFileSource::notify(const mbgl::Resource& resource, const std::shared_ptr<const mbgl::Response>& response) {
    // First, remove the request, since it might be destructed at any point now.
    auto it = pending.find(resource);
    if (it != pending.end()) {
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
        it->second.Reset();
#else
        NanDisposePersistent(it->second);
#endif
        pending.erase(it);

        // Make sure the the loop can exit when there are no pending requests.
        if (pending.empty()) {
            queue->unref();
        }
    }

    std::lock_guard<std::mutex> lock(observersMutex);

    auto observersIt = observers.find(resource);
    if (observersIt == observers.end()) {
        return;
    }

    observersIt->second->notify(response);
    observers.erase(observersIt);
}
Esempio n. 21
0
ConnectBaton::~ConnectBaton() {
  NanDisposePersistent(callback);
  if(error) {
    delete error;
  }
}