simple-http-server | Simple http server in Rust | HTTP library

The Stream returned by the repository is lazy. It uses the connection to the database in order to get the rows when the stream is being consumed by a terminal operation.

The connection is bound to the current transaction, and the current transaction is stored in a ThreadLocal variable, i.e. is bound to the thread that is eecuting your test method.

But the consumption of the stream is done on a separate thread, belonging to the thread pool used by the elastic scheduler of Reactor. So you create the lazy stream on the main thread, which has the transaction bound to it, but you consume the stream on a separate thread, which doesn't have the transaction bound to it.

Don't use reactor with JPA transactions and entities. They're incompatible.

Currently there are 2 basic concepts to handle parallel access to a web-server with various advantages and disadvantages:

1. Blocking
2. Non-Blocking

The first concept of blocking, multi-threaded server has a finite set amount of threads in a pool. Every request will get assigned to specific thread and this thread will be assigned until the request has been fully served. This is basically the same as how a the checkout queues in a super market works, a customer at a time with possible parallel lines. In most circumstances a request in a web server will be cpu-idle for the majority of the time while processing the request. This is due the fact that it has to wait for I/O: read the socket, write to the db (which is also basically IO) and read the result and write to the socket. Additionally using/creating a bunch of threads is slow (context switching) and requires a lot of memory. Therefore this concept often does not use the hardware resources it has very efficiently and has a hard limit on how many clients can be served in parallel. This property is misused in so called starvation attacks, e.g. the slow loris, an attack where usually a single client can DOS a big multi-threaded web-server with little effort.

• (+) simpler code
• (-) hard limit of parallel clients
• (-) requires more memory
• (-) inefficient use of hardware for usual web-server work
• (-) easy to DOS

Most "conventional" web server work that way, e.g. older tomcat, Apache Webserver, and everything Servlet older than 3 or 3.1 etc.

In contrast a non-blocking web-server can serve multiple clients with only a single thread. That is because it uses the non-blocking kernel I/O features. These are just kernel calls which immediately return and call back when something can be written or read, making the cpu free to do other work instead. Reusing our supermarket metaphor, this would be like, when a cashier needs his supervisor to solve a problem, he does not wait and block the whole lane, but starts to check out the next customer until the supervisor arrives and solves the problem of the first customer.

This is often done in an event loop or higher abstractions as green-threads or fibers. In essence such servers can't really process anything concurrently (of course you can have multiple non-blocking threads), but they are able to serve thousands of clients in parallel because the memory consumption will not scale as drastically as with the multi-thread concept (read: there is no hard limit on max parallel clients). Also there is no thread context-switching. The downside is, that non-blocking code is often more complex to read and write (e.g. callback-hell) and doesn't prefrom well in situations where a request does a lot of cpu-expensive work.

• (-) more complex code
• (-) performance worse with cpu intensive tasks
• (+) uses resources much more efficiently as web server
• (+) many more parallel clients with no hard-limit (except max memory)

Most modern "fast" web-servers and framework facilitate non-blocking concepts: Netty, Vert.x, Webflux, nginx, servlet 3.1+, Node, Go Webservers.

As a side note, looking at this benchmark page you will see that most of the fastest web-servers are usually non-blocking ones: https://www.techempower.com/benchmarks/

• https://stackoverflow.com/a/21155697/774398
• https://www.quora.com/What-exactly-does-it-mean-for-a-web-server-to-be-blocking-versus-non-blocking

Let's get some things straight. A server can return some html, but it is a browser that displays the html. For instance, if you type an address into a browser's address bar, that causes the browser to send a request to the server, and the server sends back a response--containing some html in the body of the response--which the browser parsers out of the response and interprets as colored text, pictures, etc., which is known as rendering the html.

Note that html is just text that is formatted a certain way, e.g.

Here is what you need to do:

1. Create a tcp server that listens on some port, and returns some html when a request comes in.

2. In a browser's address bar, specify the address where the server is listening(e.g. localhost, which is the address 127.0.0.1, which is an address on your computer) along with the port where the server is listening, e.g. http://localhost:3456.

There's one big hitch: there is no universal protocol for servers and clients (e.g browsers) to communicate with each other. The issue is caused by the way text is sent to a tcp socket. When you send some text to a tcp socket, you have no idea whether the text will get broken up into chunks, nor how long each chunk will be. The data may get sent as one chunk, or the data may get chopped into ten chunks. That presents a problem for the receiver of the data: how does the receiver know when it should stop trying to read data from the socket because no more data is coming?

To solve that problem, both the client and the server have to agree on a protocol, which is an agreed upon format for the data, so that the other side can easily parse the data, as well as an agreed upon signal that the end of the data has been reached, so that the other side can stop trying to read data from the socket. The easiest protocol is for the sender to close their socket when they are done sending data. The receiver will then attempt to keep reading data from the socket until it gets a socket error, then it knows no more data is coming.

Or, the protocol could be when the word "end" is encountered in the data--then the receiver should stop trying to read from the socket when it reads "end". But, here is an example of how that can cause problems:

If you run your code under debugger - ensure that thrown exception is actually unhandled. Code might throw exceptions and your debugger (if configured to do so) might break on them, even if those exceptions are handled (by some catch block). Since you receive 404 reply after all and not crash - I guess those exceptions are part of "normal" nancy flow and so are handled.

As for 404 - your module is internal and Nancy will not discover it. Make it public instead:

I found the answer to my problem. The header Content-Length was missing :)

Yes, the client will send Accept headers to the server.

The Accept request-header field can be used to specify certain media types which are acceptable for the response. Accept headers can be used to indicate that the request is specifically limited to a small set of desired types, as in the case of a request for an in-line image.

The client will send the URI, which is the exact location of the resource. In your case its obvious what type of resource is available at the URI, but this doesnt have to be the case, the URI is just a string of text.

Clients will send a number of headers with a request. One header they may send is an Accept header. This indicates to server what content type the client is prepared to accept as a response to the request. In the case of a stylesheet it will ask for text\css, for javascript text\javascript etc. etc.

Based on the content / tone of your question, i would suggest you probably want to read up on mimetypes and http headers. The W3C specifications are thorough, but a bit dense, there are better resources available if you just want to get your head around the basics. Ask google.