jerryscript-project / iotjs

Platform for Internet of Things with JavaScript http://www.iotjs.net

IoT.js: Platform for Internet of Things with JavaScript

You can find project details on our project page and wiki.

Memory usage and Binary footprint are measured at here with real target daily.

The following table shows the latest results on the devices:

Raspberry Pi 3
Raspberry Pi 2
STM32F4-Discovery

IRC channel: #iotjs on freenode Mailing list: [email protected], you can subscribe here and access the mailing list archive here.

Quick Start

Getting the sources

git clone https://github.com/jerryscript-project/iotjs.git
cd iotjs

How to Build

tools/build.py

How to Test

tools/testrunner.py build/x86_64-linux/debug/bin/iotjs

Trying out with a REPL

build/x86_64-linux/debug/bin/iotjs tools/repl.js

For Additional information see Getting Started.

Documentation

• Getting Started
• API Reference

License

IoT.js is Open Source software under the Apache 2.0 license. Complete license and copyright information can be found within the code.

Copyright 2015-present Samsung Electronics Co., Ltd. and other contributors

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright Node.js contributors. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

This license applies to parts of '*.js' files in '/src/js', implementing node.js compatible API, originating from the https://github.com/nodejs/node repository:

iotjs's Issues

Built-in package downloader module

As described in https://github.com/Samsung/iotjs/wiki/IoT.js-Package page we may need a built-in package downloader module, but should optional in compile time so that not consume flash space if not needed.

Condition

• has IP network that can connect to ipm registry server
• has storage

What

• server program to manipulate
• with simple commands

install <package>
list
remove <package>

NuttX build and run simple hello world

NuttX build with current iotjs, run simple hello world script.

• include jerry math lib
  • #51
  • #52 > drop
  • #55
• fix "out of memory" problem
  • grow jerry heap size: jerryscript-project/jerryscript@a28d03a
  • jerryscript-project/jerryscript#103 (Issue, Question about mem_stats)
  • jerryscript-project/jerryscript#109 (Issue, API for expanding Magic string)
  • jerryscript-project/jerryscript#111 (Issue, Byte code snap-shot to save runtime heap)
  • jerryscript-project/jerryscript#136 (PR, New External Magic String API to save heap memory)
  • register magic strings of iotjs
• prepare very simple test script

console.log("Hello IoT.js");

Implement socket.end

We've landed first implementation for socket.write(), socket.readStart().

To finish connection, socket.end() is needed which will shutdown writable stream and readable stream as well but only if there are no more data to read.

For #31

Revise ugly looking module wrapper

Currently, to make module a function we wrapping over js source with wrapper looking somewhat ugly.

  const char* wrapper[2] = {
    "(function (a, b, c) { function wwwwrap(exports,require, module) {",
    " }; wwwwrap(a, b, c); });" };

This double wrapping is because single wrapping results in bug with losing captured variables. This is probably bug on eval functionality of jerry.

Implement process.exit()

Implement process.exit(), process.exitCode and event: uncaughtException

Currently, raised an uncaught exception, the program abort. This should be treated in uncaughtException handler and if no handler for it, program exit with corresponding exitcode.

related #78, #36

test_fs.js sometimes failed.

It looks like read returns empty buffer very occasionally.

Generate jerry third-party math library for embed systems

Need to change the build.py script so that it generates math library in jerry third-party.

Complete HTTP module

• http.METHODS
• http.STATUS_CODES
• http.createServer([requestListener])
• Class: http.Server
  • Event: 'request'
  • Event: 'connection'
  • Event: 'close'
  • server.listen(port[, hostname][, backlog][, callback])
  • server.close([callback])
  • server.setTimeout(msecs, callback)
  • server.timeout
• Class: http.ServerResponse
  • Event: 'close'
  • Event: 'finish'
  • response.writeHead(statusCode[, statusMessage][, headers])
  • response.setTimeout(msecs, callback)
  • response.statusCode
  • response.statusMessage
  • response.setHeader(name, value)
  • response.headersSent
  • response.getHeader(name)
  • response.removeHeader(name)
  • response.write(chunk[, encoding][, callback])
  • response.end([data][, encoding][, callback])
• http.request(options[, callback])
• http.get(options[, callback])
• Class: http.ClientRequest
  • Event: 'response'
  • Event: 'socket'
  • request.write(chunk[, encoding][, callback])
  • request.end([data][, encoding][, callback])
  • request.setTimeout(timeout[, callback])
• http.IncomingMessage
  • Event: 'close'
  • message.headers
  • message.setTimeout(msecs, callback)
  • message.method
  • message.url
  • message.statusCode
  • message.statusMessage
  • message.socket

Reimplement test suites using `assert()` instead printing out.

Complete Timers module

Implement Timers methods

Required Items:

• setTimeout()
• clearTime()
• setInterval()
• clearInterval

Complete net module

https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Net

net

• createServer()
• connect(options, connectListener)
• connect(port, host, connectListener)
• createConnection(opitions, connectListener)
• createConnection(port, host, connectListener)

net.Server

• listen(options, callback)
• listen(port, host, callback)
• close()
• event: listening
• event: connection
• event: close
• event: error

net.Socket

• new Socket(options)
• connect(port, host, connectListener)
• write(data, callback)
• end(data)
• destroy()
• resume()
• pause()
• setTimeout()
• setKeepAlive()
• event: lookup
• event: connect
• event: data
• event: drain
• event: end
• event: timeout
• event: close
• event: error

Hardware control APIs

As of today, nodejs is on the discuss to support hardware and libuv is ready with uv_device_t PR.
For IoT.js, how are we going to support hardware control and manage devices?
First PR #105 needs some more adjustments and we need to discuss how to provide the API and manage H/W boards and devices. GPIO-control-ideas is prepared to draw everyones sketch.
Please add comments and write down to WiKi page.

Prepare module package description

We need to

• describe what package.json should contain for the module
• how it is registered to registry server
• how it is downloaded to the device
• how it is used in the program

Change `print` to `console`

Lots of test file use print to print out text to screen.
But print is not offered by our API, instead we can use console.

Process exit() before cleanup

jerryscript-project/jerryscript#242 (comment)

Jerry Requirement - String.prototype.slice

Need String.prototype.slice(ECMA262 15.5.4.13) supported by Jerry.

Remove "unused variable" warnings on release build.

Many warnings are reported during release build which are not appear in debug build.
The pattern of this problem is below form:

int a = <expr>;
assert(a);

assert eats its argument expression and ends in empty expression on release build, resulting the a unused.
Let's introduce redefinition of assert() like this:

#ifdef NDEBUG
 #define IOTJS_ASSERT(x) ((void)(x))
#else
 #define IOTJS_ASSERT(x) assert(x)
#endif

Implement writableStream

Jerry Requirement - Array.prototype.push

Need Array.prototype.push(ECMA262-15.4.4.7) supported by Jerry.

Process native_sources to native side

process has native_sources property with text source that will consume JerryScript heap.
I think it's better remove this and related implementation to native side to save the JavaScript heap.

ReadableStream flowing mode

Readable stream has two mode: flowing and paused.
Currently IoT.js only implemented paused mode. But many use cases run in flowing mode so we need to implement flowing mode before start implementing other modules like fs, net, etc.

[Meta] Jerry requirements

This is meta issue for all works related with Jerry Javascript Engine.

Add Timers method to global space

Timers methods need to be exposed to global.
Implement in start_iotjs()

Reimplement test_stat.js, add it run_pass.

Wrapping `jerry_api_eval()` with `JObject`

Used in Compile and CompileNativePtr in 'iotjs_module_process.cpp'.

No error or warning when given invalid file

Run iotjs with invalid file name, some random string.
I think it should show some error or waring that file does not exist on invalid file.
Currently it shows nothing.
Test with 1777b85

Implement error handling process.compile and process.compileNativePtr

process.compile and process.compileNativePtr have no error handling routine when jerry_api_eval return error.

Jerry Requirement - Object.create

Need Object.create(ECMA262 12.2.3.5) supported by Jerry.

Jerry Requirement - Array.prototype.slice

Need Array.prototype.slice(ECMA262 15.4.4.10) supported by Jerry.

Implement native JS(src/js/*.js) modules as c builtin code

We have to discuss the following topics.

1. Benifit
   • size
   • performance
2. Feasibility

Determine module search path order

Nodejs search for a module in the order of
(1) ./node_modules
(2) $NODE_PATH/node_modules
(3) $HOME/node_modules
(4) $HOME/node_libraries
(5) (node execpath)/node/lib

We need to determine the search order w.r.t. multiple plaforms since enviroment or cwd is not available in small devices.

Debug message to console

Need debug message logging like in JerryScript

• jerryscript-project/jerryscript#79

+#ifdef JERRY_ENABLE_LOG
+#define JERRY_LOG(lvl, ...) \
+  do \
+  { \
+    if (lvl <= jerry_debug_level && jerry_log_file) \
+    { \
+      fprintf (jerry_log_file, __VA_ARGS__); \
+    } \
+  } \
+  while (0)
+
+#define JERRY_DLOG(...) JERRY_LOG (1, __VA_ARGS__)
+#define JERRY_DDLOG(...) JERRY_LOG (2, __VA_ARGS__)
+#define JERRY_DDDLOG(...) JERRY_LOG (3, __VA_ARGS__)
+#else /* !JERRY_ENABLE_LOG */
+#define JERRY_DLOG(...) \
+  do \
+  { \
+    if (false) \
+    { \
+      jerry_ref_unused_variables (0, __VA_ARGS__); \
+    } \
+  } while (0)
+#define JERRY_DDLOG(...) JERRY_DLOG (__VA_ARGS__)
+#define JERRY_DDDLOG(...) JERRY_DLOG (__VA_ARGS__)
+#endif /* !JERRY_ENABLE_LOG */

readable stream does not emit 'end' event

After applying daf7b02 commit,
readable stream does not emit 'end' event after pushing null into stream.

Jerry Requirement - Array.isArray

Need Array.isArray(ECMA262-15.4.3.2) supported by Jerry.

Show correct source position when assert failure

current message for assert failure is always same position

src/iotjs_binding.cpp:329: iotjs::JObject iotjs::JObject::Call(iotjs::JObject&, iotjs::JArgList&): Assertion `is_ok' failed.
Aborted (core dumped)

need to fix this to show real position.

Complete document: API References

https://github.com/Samsung/iotjs/wiki/IoT.js%20API%20Reference

• Basic modules
  • assert (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Assert)
  • buffer (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Buffer)
  • dns (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-DNS)
  • events (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Events)
  • fs
  • gpio (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-GPIO)
  • http
  • module
  • net (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Net)
  • process
  • stream
  • timers (https://github.com/Samsung/iotjs/wiki/IoT.js-API:-Timers)

Embedding packages in iotjs

As described in https://github.com/Samsung/iotjs/wiki/IoT.js-Package page, we may need to embed downloaded packages inside iotjs. It can be done such as

1. download packages to some specific folder
2. give option to build script to enable embedding with the specific folder
3. convert package scripts to C code
4. require() finds packages in embed area

Application script should exist at the root of the specific folder.

Jerry Requirement - Array.prototype.shift

Need Array.prototype.shift(ECMA262-15.4.4.9) supported by Jerry.

Complete assert module

• assert
  • assert.fail
  • assert.equal
  • assert.notEqual
  • assert.strictEqual
  • assert.notStrictEqual
  • assert.throws
  • assert.doesNotThrows

Documentation build test.

Now we have automatic build test feature.
The build test is mainly done by "tools/check_test.py" script.

Document it, expected contents are:

• build check process
• kind of test suite
  • run pass
  • run fail
• how to write test suite
• test suite attributes

Wrapper for Javascript native function binding.

Currently IoT.js binds its native javascipt function using external handler API of Jerry Engine. The prototype of the handler is defined as:

typedef bool (*jerry_external_handler_t) (const jerry_api_object_t *function_obj_p,
                                          const jerry_api_value_t *this_p,
                                          jerry_api_value_t *ret_val_p,
                                          const jerry_api_value_t args_p [],
                                          const uint16_t args_count);

And each module should implement handlers like:

static bool ToString(const jerry_api_object_t *function_obj_p,
                     const jerry_api_value_t *this_p,
                     jerry_api_value_t *ret_val_p,
                     const jerry_api_value_t args_p [],
                     const uint16_t args_cnt) {
  assert(args_cnt == 0);

  JObject buffer_obj(this_p, false);
  char* buffer = reinterpret_cast<char*>(buffer_obj.GetNative());
  assert(buffer != NULL);

  JObject jstring(buffer);
  jstring.Ref();
  *ret_val_p = jstring.val();

  return true;
}

In spite of JObject wrapper for object type, there is no wrapping layer for external handlers. I think we should introduce a layer that wrap external handler in consistent way with JObject wrapper so that developers who does not know about jerry also could work with it more easily.

next tick not working correctly.

Running test_next_tick.js should end with five lines of output but it is printing only 2 lines before finish.

Main loop should remain as long as there are requests to be handled.

Jerry Requirement - arguments

Need arguments(ECMA262 10.6) supported by Jerry.

Merge & Build automation

RFC: Merge & Build Automation.

Summary

Introduce a automated build system for continuous integration. There are several well-known build systems such as buildbot, jenkins, hudson, and etc. By using automated build system, we can not only reduce our merge or integration cost but also eliminate human mistakes.

Motive

The process of source integrating is a work of routine. But it requires for people delicate work from start to end to finish without making any mistake. Unfortunately we human being make mistakes even more when the work is a kind of routine. And also it takes a time to be done.
By using automated build system, we are free from such matters. The most of the steps in a process of source integration - except an important step, reviewing - are programmable.

What can be done by automated build system

Automated build system may conduct following routines.

• Daily building and reporting result.
• Daily testing including benchmark and reporting result.
• Build by trigger.
• Test by trigger.

It also can do followings in conjunction with github web hook API.

• If there is a new issue registered, report it.
• If there is a new pull request, report it.
• If there is a reviewed pull request, build it.
  • If the build and test finished successfully, merge it to master.

Automate Jerry external magic string registration.

From #90, IoT.js registers commonly used string literal as external magic string of jerry engine.
Unfortunately we need to periodically maintain list of magic string by hand.

I think we can automate this by running a script at build process like "iotjs_js.h" file gereration.

Implement process.nextTick()

Jerry Requirement - Function.prototype.apply

Need Function.prototype.apply(ECMA262 15.3.4.3) supported by Jerry.

Complete fs module

Complete implementation of fs module.

Required Items:

• fs.access()
• fs.accessSync()
• fs.exist() (deprecated)
• fs.existSync() (deprecated)
• fs.stat()
• fs.statSync()
• fs.chmod()
• fs.chmodSync()
• fs.chown()
• fs.chownSync()
• fs.rename()
• fs.renameSync()
• fs.close()
• fs.closeSync()
• fs.open()
• fs.openSync()
• fs.read()
• fs.readSync()
• fs.readFile()
• fs.readFileSync()
• fs.write()
• fs.writeSync()
• fs.writeFile()
• fs.writeFileSync()
• fs.appendFile()
• fs.appendFileSync()
• fs.truncate()
• fs.truncateSync()
• fs.mkdir()
• fs.mkdirSync()
• fs.rmdir()
• fs.rmdirSync()
• fs.readdir()
• fs.readdirSync()
• fs.unlink()
• fs.unlinkSync()

Apply Array.splice to timers_list in timers.js

    // Todo: use splice when available
    var j, leng = timers_list.length;
    for (j = idx; j < leng; j++) {
      timers_list[j] = timers_list[j+1];
    }
    timers_list.pop();

• PR #33
• Jerry jerryscript-project/jerryscript#3

Size of script code buffer

Hello.

Code buffer size argument of jerry_api_eval in JHANDLER_FUNCTION(Compile, handler) and JHANDLER_FUNCTION(CompileNativePtr, handler) is calculated incorrectly : sizeof (code) equals to size of pointer, not buffer size.

Maybe, this could be fixed with the following:

diff --git a/src/iotjs_module_process.cpp b/src/iotjs_module_process.cpp
index 282bc09..bd73a3f 100644
--- a/src/iotjs_module_process.cpp
+++ b/src/iotjs_module_process.cpp
@@ -87,7 +87,7 @@ JHANDLER_FUNCTION(Compile, handler){

   char* code = handler.GetArg(0)->GetCString();
   JRawValueType ret_val;
-  jerry_api_eval(code,sizeof(code),true,false,&ret_val);
+  jerry_api_eval(code,strlen(code),true,false,&ret_val);
   JObject::ReleaseCString(code);

   JObject ret(&ret_val);
@@ -116,7 +116,7 @@ JHANDLER_FUNCTION(CompileNativePtr, handler){
   strcat(code,wrapper[1]);

   JRawValueType ret_val;
-  jerry_api_eval(code,sizeof(code),true,false,&ret_val);
+  jerry_api_eval(code,len,true,false,&ret_val);
   JObject::ReleaseCString(code);

   JObject ret(&ret_val);