sshirokov / hinge Goto Github PK

There should be some sort of wrapper, ideally for NST to support unit testing within the Hinge reactor.

It could scaffold the NST environment then begin the evaluation of tests in response to events. Nothing too fancy.

The socket, server and zmq-socket classes lack nicer wrappers for setting socket options, backlog settings and zmq_socket options without reaching into the wrapping class to the underlying handle.

These methods should exist as first class wrappers.

Hey,

I've been developing something very similar to this. You can check it out at http://github.com/sykopomp/conserv. I'd been thinking of trying to use libev instead of iolib to see if there was any difference in performance and portability. How has cl-ev been working out for you?

Please consider adding :description, :author and :license information to your ASDF system(s). This will greatly help Quicklisp users and make it easier for them to report bugs.

More information:

http://blog.quicklisp.org/2015/05/looking-for-more-metadata.html
https://www.quicklisp.org

Right now there is no case designed for receiving a stream of multipart ZeroMQ messages.

Need basic async APIs for

• File open
• File read
• File write
• File rename

This ticket should also implement the stat watcher from libev and include an API for it's operation.

Libev recommends against using IO watchers for disk-based descriptors, so this work might be best carried out in the threadpool.

When I try to do this:

git submodule update --init --recursive

I get this:

Submodule 'vendor/cffi' () registered for path 'vendor/cffi'
Submodule 'vendor/cl-ev' () registered for path 'vendor/cl-ev'
Submodule 'vendor/lisp-zmq' () registered for path 'vendor/lisp-zmq'
fatal: Needed a single revision
Unable to find current revision in submodule path 'vendor/cffi'

What should I do?

When I run `make develop' (CentOS 6.4 x86_64) with the latest hinge cloned off of github, at some point make produces the following:

make[1]: Entering directory `/home/icon/tools/hinge/vendor'
=> Updating submodules
(cd .. ; git submodule update --init --recursive;)
Initialized empty Git repository in /home/icon/tools/hinge/vendor/cl-ev/.git/
Warning: Permanently added the RSA host key for IP address '192.30.252.131' to the list of known hosts.
Permission denied (publickey).
fatal: The remote end hung up unexpectedly
Clone of '[email protected]:sshirokov/cl-ev.git' into submodule path 'vendor/cl-ev' failed
make[1]: *** [init] Error 1
make[1]: Leaving directory `/home/icon/tools/hinge/vendor'
make: *** [init] Error 2

I'm not sure if this is an issue with hinge or something else, but I can ping the stated address and I can clone cl-ev manually into vendors/cl-ev, after which rerunning `make develop' finishes successfully with 'You should be good to go'.

The links in https://github.com/sshirokov/hinge/wiki/Classes should be filled in to describe
the classes in the headers and the methods that are specialized for them

A quick tutorial should also be written that walks from installing a LISP implementation
to getting a functional HTTP "Hello World" application in a different package.

The defer macro should schedule the execution of the thunk into the emit or deliver queues rather than scheduling a brand new one-off timer.

This might mandate that the queue API grows up a little.

Right now the on-read callback for a zmq-socket drains the 0MQ socket in a blocking function in the I/O callback until the read would block before returning from the callback.

Instead, the on-read callback should start a high-priority idle watcher (Higher than the delivery watcher, and if this approach is taken the priority values should be externalized to something resembling constants) which will then drain the socket until it would block, before resuming the IO callback.

First, wrap emit and deliver into something that uses the running-queue API

Then remove all of the -queue and -runner slots from hinge and unify them into something like an array
indexed by priority or a hash-table keyed by :name.

luvit has a very similar concept, and just wrapped libuv v8 and a few others with a similar api as node making it easy to work with with the added fast ffi benefit.
Also Tim Casswell @creationix was really nice education and helpful.
The build steps are "get lit && make luv && luvit` or something comical like that back in the day

Right now the socket on-write callback writes a single buffer to the wire even when multiple writes are queued regardless of the size, this causes less than optimal write performance when many small writes are queued as it forces them to be written in several iterations of the event loop.

Ideally the on-write callback will bundle as many writes as it can into a fixed larger size buffer before attempting to write to get as much data across the wire as possible then fire any callbacks that should be fired as a result of the IO and update the offset in the last logical chunk that it tried and fail to write.

This change would force things like chunked HTTP replies to be written to the wire in larger chunks rather than several tiny writes without affecting the chain of callbacks that has an expectation of being invoked on write completion.

Hinge needs an Async HTTP client. It should be modeled somewhat on the node.js http.request.

Any state machines that can be reused from the HTTP parser should be reused, like the header reader.