26333844816

Committed 23 May 2026 01:23PM UTC coverage: 68.091% (-4.3%) from 72.394%

Build # 26333844816

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #441 from hanazuki/fix-deadlock

Fix deadlock when callbacks return malformed results

Coverage Stats

363 of 738 branches covered (49.19%)

Branch coverage included in aggregate %.

50 of 61 new or added lines in 4 files covered. (81.97%)

1 existing line in 1 file now uncovered.

561 of 619 relevant lines covered (90.63%)

217.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.62

/src/JsonnetWorker.cpp

// SPDX-License-Identifier: MIT
#include "JsonnetWorker.hpp"
#include <memory>
#include <string_view>
#include <utility>
#include <vector>
#include "JsonnetAddon.hpp"

namespace nodejsonnet {

  JsonnetWorker::JsonnetWorker(Napi::Env env, std::shared_ptr<JsonnetVm> vm, std::unique_ptr<Op> op)
    : Napi::AsyncWorker(env, "jsonnet"), vm(std::move(vm)), op(std::move(op)),
      deferred(Napi::Promise::Deferred::New(env)) {
  }

  void JsonnetWorker::Execute() {
    try {
      result = op->execute(*vm);
    } catch(JsonnetError const &e) {
      errorType = ErrorType::Jsonnet;
      throw;
    }
  }

  void JsonnetWorker::OnOK() {
    deferred.Resolve(op->toValue(Env(), std::move(result)));
  }

  void JsonnetWorker::OnError(Napi::Error const &error) {
    auto e = error.Value();

    switch(errorType) {
    case ErrorType::Generic:
      break;
    case ErrorType::Jsonnet:
      e = JsonnetAddon::getInstance(e.Env())
            .getExport("JsonnetError")
            .As<Napi::Function>()
            .New({e.Get("message")});
      break;
    default:
      abort();  // unreachable
    }

    deferred.Reject(e);
  }

  JsonnetWorker::EvaluateFileOp::EvaluateFileOp(std::string filename)
    : filename(std::move(filename)) {
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateFileOp::execute(JsonnetVm const &vm) {
    return vm.evaluateFile(filename);
  }

  Napi::Value JsonnetWorker::EvaluateFileOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {
    return Napi::String::New(env, buffer.get());
  }

  JsonnetWorker::EvaluateSnippetOp::EvaluateSnippetOp(std::string snippet, std::string filename)
    : snippet(std::move(snippet)), filename(std::move(filename)) {
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetOp::execute(JsonnetVm const &vm) {
    return vm.evaluateSnippet(filename, snippet);
  }

  Napi::Value JsonnetWorker::EvaluateSnippetOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {
    return Napi::String::New(env, buffer.get());
  }

  namespace {
    Napi::Value parseMultiValue(Napi::Env env, JsonnetVm::Buffer buffer) {
      auto result = Napi::Object::New(env);

      for(auto p = buffer.get(); *p;) {
        std::string_view const name(p);
        p += name.size() + 1;
        std::string_view const json(p);
        p += json.size() + 1;

        result.Set(Napi::String::New(env, name.data(), name.size()),
          Napi::String::New(env, json.data(), json.size()));
      }

      return result;
    }
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateFileMultiOp::execute(JsonnetVm const &vm) {
    return vm.evaluateFileMulti(filename);
  }

  Napi::Value JsonnetWorker::EvaluateFileMultiOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {
    return parseMultiValue(env, std::move(buffer));
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetMultiOp::execute(JsonnetVm const &vm) {
    return vm.evaluateSnippetMulti(filename, snippet);
  }

  Napi::Value JsonnetWorker::EvaluateSnippetMultiOp::toValue(
    Napi::Env env, JsonnetVm::Buffer buffer) {
    return parseMultiValue(env, std::move(buffer));
  }

  namespace {
    Napi::Value parseStreamValue(Napi::Env env, JsonnetVm::Buffer buffer) {
      std::vector<napi_value> jsons;
      for(auto p = buffer.get(); *p;) {
        std::string_view const json(p);
        p += json.size() + 1;
        jsons.push_back(Napi::String::New(env, json.data(), json.size()));
      }

      auto result = Napi::Array::New(env, jsons.size());
      for(size_t i = 0; i < jsons.size(); ++i) {
        result.Set(i, jsons[i]);
      }
      return result;
    }
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateFileStreamOp::execute(JsonnetVm const &vm) {
    return vm.evaluateFileStream(filename);
  }

  Napi::Value JsonnetWorker::EvaluateFileStreamOp::toValue(
    Napi::Env env, JsonnetVm::Buffer buffer) {
    return parseStreamValue(env, std::move(buffer));
  }

  JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetStreamOp::execute(JsonnetVm const &vm) {
    return vm.evaluateSnippetStream(filename, snippet);
  }

  Napi::Value JsonnetWorker::EvaluateSnippetStreamOp::toValue(
    Napi::Env env, JsonnetVm::Buffer buffer) {
    return parseStreamValue(env, std::move(buffer));
  }

}

1	// SPDX-License-Identifier: MIT
2	#include "JsonnetWorker.hpp"
3	#include <memory>
4	#include <string_view>
5	#include <utility>
6	#include <vector>
7	#include "JsonnetAddon.hpp"
8
9	namespace nodejsonnet {
10
11	JsonnetWorker::JsonnetWorker(Napi::Env env, std::shared_ptr<JsonnetVm> vm, std::unique_ptr<Op> op)	2,072✔
12	: Napi::AsyncWorker(env, "jsonnet"), vm(std::move(vm)), op(std::move(op)),	2,072✔
13	deferred(Napi::Promise::Deferred::New(env)) {	2,072!
14	}	×
15
16	void JsonnetWorker::Execute() {	1,036✔
17	try {
18	result = op->execute(*vm);	1,036✔
19	} catch(JsonnetError const &e) {	1,544!
20	errorType = ErrorType::Jsonnet;	508✔
21	throw;	508!
22	}	508!
23	}	1,544✔
24
25	void JsonnetWorker::OnOK() {	528✔
26	deferred.Resolve(op->toValue(Env(), std::move(result)));	528!
27	}	528✔
28
29	void JsonnetWorker::OnError(Napi::Error const &error) {	508✔
30	auto e = error.Value();	508✔
31
32	switch(errorType) {	508!
33	case ErrorType::Generic:
34	break;
35	case ErrorType::Jsonnet:
36	e = JsonnetAddon::getInstance(e.Env())	1,016✔
37	.getExport("JsonnetError")	508✔
38	.As<Napi::Function>()	508✔
39	.New({e.Get("message")});	508✔
40	break;	508✔
41	default:
NEW 42	abort(); // unreachable	×
43	}
44
45	deferred.Reject(e);	508✔
46	}	508✔
47
48	JsonnetWorker::EvaluateFileOp::EvaluateFileOp(std::string filename)	716✔
49	: filename(std::move(filename)) {	716✔
50	}	716✔
51
52	JsonnetVm::Buffer JsonnetWorker::EvaluateFileOp::execute(JsonnetVm const &vm) {	700✔
53	return vm.evaluateFile(filename);	700✔
54	}
55
56	Napi::Value JsonnetWorker::EvaluateFileOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {	276✔
57	return Napi::String::New(env, buffer.get());	276✔
58	}
59
60	JsonnetWorker::EvaluateSnippetOp::EvaluateSnippetOp(std::string snippet, std::string filename)	320✔
61	: snippet(std::move(snippet)), filename(std::move(filename)) {	320✔
62	}	320✔
63
64	JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetOp::execute(JsonnetVm const &vm) {	296✔
65	return vm.evaluateSnippet(filename, snippet);	296✔
66	}
67
68	Napi::Value JsonnetWorker::EvaluateSnippetOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {	228✔
69	return Napi::String::New(env, buffer.get());	228✔
70	}
71
72	namespace {
73	Napi::Value parseMultiValue(Napi::Env env, JsonnetVm::Buffer buffer) {	12✔
74	auto result = Napi::Object::New(env);	12✔
75
76	for(auto p = buffer.get(); *p;) {	36✔
77	std::string_view const name(p);	24✔
78	p += name.size() + 1;	24✔
79	std::string_view const json(p);	24✔
80	p += json.size() + 1;	24✔
81
82	result.Set(Napi::String::New(env, name.data(), name.size()),	48✔
83	Napi::String::New(env, json.data(), json.size()));	24✔
84	}	24✔
85
86	return result;	12✔
87	}	12✔
88	}
89
90	JsonnetVm::Buffer JsonnetWorker::EvaluateFileMultiOp::execute(JsonnetVm const &vm) {	8✔
91	return vm.evaluateFileMulti(filename);	8✔
92	}
93
94	Napi::Value JsonnetWorker::EvaluateFileMultiOp::toValue(Napi::Env env, JsonnetVm::Buffer buffer) {	4✔
95	return parseMultiValue(env, std::move(buffer));	4!
96	}	×
97
98	JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetMultiOp::execute(JsonnetVm const &vm) {	12✔
99	return vm.evaluateSnippetMulti(filename, snippet);	12✔
100	}
101
102	Napi::Value JsonnetWorker::EvaluateSnippetMultiOp::toValue(	8✔
103	Napi::Env env, JsonnetVm::Buffer buffer) {
104	return parseMultiValue(env, std::move(buffer));	8!
105	}	×
106
107	namespace {
108	Napi::Value parseStreamValue(Napi::Env env, JsonnetVm::Buffer buffer) {	12✔
109	std::vector<napi_value> jsons;	12✔
110	for(auto p = buffer.get(); *p;) {	36✔
111	std::string_view const json(p);	24✔
112	p += json.size() + 1;	24✔
113	jsons.push_back(Napi::String::New(env, json.data(), json.size()));	24!
114	}	24✔
115
116	auto result = Napi::Array::New(env, jsons.size());	12!
117	for(size_t i = 0; i < jsons.size(); ++i) {	36✔
118	result.Set(i, jsons[i]);	24!
119	}	24✔
120	return result;	12✔
121	}	12✔
122	}
123
124	JsonnetVm::Buffer JsonnetWorker::EvaluateFileStreamOp::execute(JsonnetVm const &vm) {	8✔
125	return vm.evaluateFileStream(filename);	8✔
126	}
127
128	Napi::Value JsonnetWorker::EvaluateFileStreamOp::toValue(	4✔
129	Napi::Env env, JsonnetVm::Buffer buffer) {
130	return parseStreamValue(env, std::move(buffer));	4!
131	}	×
132
133	JsonnetVm::Buffer JsonnetWorker::EvaluateSnippetStreamOp::execute(JsonnetVm const &vm) {	12✔
134	return vm.evaluateSnippetStream(filename, snippet);	12✔
135	}
136
137	Napi::Value JsonnetWorker::EvaluateSnippetStreamOp::toValue(	8✔
138	Napi::Env env, JsonnetVm::Buffer buffer) {
139	return parseStreamValue(env, std::move(buffer));	8!
140	}	×
141
142	}

hanazuki / node-jsonnet / 26333844816

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous