foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-28 16:20:57 -05:00
Code Issues Packages 1 Wiki Activity

Use pub/sub instead of send/recv

Browse source
This commit is contained in:
Ryan Dahl 2018-06-11 19:18:53 +02:00
parent 9590c87c62
commit 2443f7efee
6 changed files with 40 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
deno2/deno.cc
View file

@ -109,8 +109,8 @@ void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
fflush(stdout);
}
// Sets the recv callback.
void Recv(const v8::FunctionCallbackInfo<v8::Value>& args) {
// Sets the sub callback.
void Sub(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::Isolate* isolate = args.GetIsolate();
Deno* d = reinterpret_cast<Deno*>(isolate->GetData(0));
assert(d->isolate == isolate);
@ -121,11 +121,11 @@ void Recv(const v8::FunctionCallbackInfo<v8::Value>& args) {
assert(v->IsFunction());
v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(v);
d->recv.Reset(isolate, func);
d->sub.Reset(isolate, func);
}
// Called from JavaScript, routes message to golang.
void Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
void Pub(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::Isolate* isolate = args.GetIsolate();
Deno* d = static_cast<Deno*>(isolate->GetData(0));
assert(d->isolate == isolate);
@ -213,13 +213,13 @@ v8::StartupData MakeSnapshot(v8::StartupData* prev_natives_blob,
CHECK(
global->Set(context, deno::v8_str("deno_print"), print_val).FromJust());
auto recv_tmpl = v8::FunctionTemplate::New(isolate, Recv);
auto recv_val = recv_tmpl->GetFunction(context).ToLocalChecked();
CHECK(global->Set(context, deno::v8_str("deno_recv"), recv_val).FromJust());
auto sub_tmpl = v8::FunctionTemplate::New(isolate, Sub);
auto sub_val = sub_tmpl->GetFunction(context).ToLocalChecked();
CHECK(global->Set(context, deno::v8_str("deno_sub"), sub_val).FromJust());
auto send_tmpl = v8::FunctionTemplate::New(isolate, Send);
auto send_val = send_tmpl->GetFunction(context).ToLocalChecked();
CHECK(global->Set(context, deno::v8_str("deno_send"), send_val).FromJust());
auto pub_tmpl = v8::FunctionTemplate::New(isolate, Pub);
auto pub_val = pub_tmpl->GetFunction(context).ToLocalChecked();
CHECK(global->Set(context, deno::v8_str("deno_pub"), pub_val).FromJust());
bool r = Load(context, js_filename, js_source);
assert(r);
@ -274,10 +274,10 @@ bool deno_load(Deno* d, const char* name_s, const char* source_s) {
return deno::Load(context, name_s, source_s);
}
// Routes message to the javascript callback set with deno_recv().
// Routes message to the javascript callback set with deno_sub().
// False return value indicates error. Check deno_last_exception() for exception
// text. Caller owns buf.
bool deno_send(Deno* d, deno_buf buf) {
bool deno_pub(Deno* d, deno_buf buf) {
v8::Locker locker(d->isolate);
v8::Isolate::Scope isolate_scope(d->isolate);
v8::HandleScope handle_scope(d->isolate);
@ -287,9 +287,9 @@ bool deno_send(Deno* d, deno_buf buf) {
v8::TryCatch try_catch(d->isolate);
auto recv = d->recv.Get(d->isolate);
if (recv.IsEmpty()) {
d->last_exception = "deno_recv has not been called.";
auto sub = d->sub.Get(d->isolate);
if (sub.IsEmpty()) {
d->last_exception = "deno_sub has not been called.";
return false;
}
@ -302,7 +302,7 @@ bool deno_send(Deno* d, deno_buf buf) {
assert(!args[0].IsEmpty());
assert(!try_catch.HasCaught());
recv->Call(context->Global(), 1, args);
sub->Call(context->Global(), 1, args);
if (try_catch.HasCaught()) {
deno::HandleException(context, try_catch.Exception());

14
deno2/deno_internal.h
View file

@ -12,9 +12,9 @@ extern "C" {
struct deno_s {
v8::Isolate* isolate;
std::string last_exception;
v8::Persistent<v8::Function> recv;
v8::Persistent<v8::Function> sub;
v8::Persistent<v8::Context> context;
deno_recv_cb cb;
deno_sub_cb cb;
void* data;
};
}
@ -22,13 +22,13 @@ struct deno_s {
namespace deno {
void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
void Recv(const v8::FunctionCallbackInfo<v8::Value>& args);
void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
void Sub(const v8::FunctionCallbackInfo<v8::Value>& args);
void Pub(const v8::FunctionCallbackInfo<v8::Value>& args);
static intptr_t external_references[] = {reinterpret_cast<intptr_t>(Print),
reinterpret_cast<intptr_t>(Recv),
reinterpret_cast<intptr_t>(Send), 0};
reinterpret_cast<intptr_t>(Sub),
reinterpret_cast<intptr_t>(Pub), 0};
Deno* NewFromSnapshot(void* data, deno_recv_cb cb);
Deno* NewFromSnapshot(void* data, deno_sub_cb cb);
v8::StartupData MakeSnapshot(v8::StartupData* prev_natives_blob,
v8::StartupData* prev_snapshot_blob,

4
deno2/from_snapshot.cc
View file

@ -21,7 +21,7 @@ namespace deno {
#include "snapshot_deno.cc"
#endif
Deno* NewFromSnapshot(void* data, deno_recv_cb cb) {
Deno* NewFromSnapshot(void* data, deno_sub_cb cb) {
auto natives_blob = *StartupBlob_natives();
auto snapshot_blob = *StartupBlob_snapshot();
@ -52,7 +52,7 @@ Deno* NewFromSnapshot(void* data, deno_recv_cb cb) {
} // namespace deno
extern "C" {
Deno* deno_new(void* data, deno_recv_cb cb) {
Deno* deno_new(void* data, deno_sub_cb cb) {
return deno::NewFromSnapshot(data, cb);
}
}

6
deno2/include/deno.h
View file

@ -18,14 +18,14 @@ struct deno_s;
typedef struct deno_s Deno;
// The callback from V8 when data is sent.
typedef deno_buf (*deno_recv_cb)(Deno* d, deno_buf buf);
typedef deno_buf (*deno_sub_cb)(Deno* d, deno_buf buf);
void deno_init();
const char* deno_v8_version();
void deno_set_flags(int* argc, char** argv);
// Constructor
Deno* deno_new(void* data, deno_recv_cb cb);
Deno* deno_new(void* data, deno_sub_cb cb);
// Returns false on error.
// Get error text with deno_last_exception().
@ -33,7 +33,7 @@ bool deno_load(Deno* d, const char* name_s, const char* source_s);
// Returns false on error.
// Get error text with deno_last_exception().
bool deno_send(Deno* d, deno_buf buf);
bool deno_pub(Deno* d, deno_buf buf);
const char* deno_last_exception(Deno* d);

4
deno2/js/mock_runtime.js
View file

@ -10,8 +10,8 @@ function assert(cond) {
if (!cond) throw Error("mock_runtime.js assert failed");
}
function recvabc() {
deno_recv((msg) => {
function subabc() {
deno_sub((msg) => {
assert(msg instanceof ArrayBuffer);
assert(msg.byteLength === 3);
});

20
deno2/mock_runtime_test.cc
View file

@ -27,25 +27,25 @@ deno_buf strbuf(const char* str) {
return deno_buf{d, strlen(str)};
}
TEST(MockRuntimeTest, SendSuccess) {
TEST(MockRuntimeTest, PubSuccess) {
Deno* d = deno_new(NULL, NULL);
EXPECT_TRUE(deno_load(d, "a.js", "recvabc();"));
EXPECT_TRUE(deno_send(d, strbuf("abc")));
EXPECT_TRUE(deno_load(d, "a.js", "subabc();"));
EXPECT_TRUE(deno_pub(d, strbuf("abc")));
deno_dispose(d);
}
TEST(MockRuntimeTest, SendByteLength) {
TEST(MockRuntimeTest, PubByteLength) {
Deno* d = deno_new(NULL, NULL);
EXPECT_TRUE(deno_load(d, "a.js", "recvabc();"));
// We send the wrong sized message, it should throw.
EXPECT_FALSE(deno_send(d, strbuf("abcd")));
EXPECT_TRUE(deno_load(d, "a.js", "subabc();"));
// We pub the wrong sized message, it should throw.
EXPECT_FALSE(deno_pub(d, strbuf("abcd")));
deno_dispose(d);
}
TEST(MockRuntimeTest, SendNoCallback) {
TEST(MockRuntimeTest, PubNoCallback) {
Deno* d = deno_new(NULL, NULL);
// We didn't call deno_recv(), sending should fail.
EXPECT_FALSE(deno_send(d, strbuf("abc")));
// We didn't call deno_sub(), pubing should fail.
EXPECT_FALSE(deno_pub(d, strbuf("abc")));
deno_dispose(d);
}