Preskoči na glavno vsebino

Ryelang - controlled file serving example and comparison to Python


This is as anecdotal as it gets, but basic HTTP serving functions in Rye seem to be working quite OK. They do directly use the extremely solid Go's HTTP functions, so that should be somewhat expected.

I made a ryelang.org web-server with few lines of Rye code 3 months ago and the process was running ever since and served more than 30.000 pages. If not else, it  seems there are no inherent memory leaks in Rye interpreter. Those would probably show up in a 3 month long running process?

And now I got another simple project. I needed to make a HTTP API for some mobile app. API should accept a key, and return / download a binary file in response if the key is correct. Otherwise it should return a HTTP error.

So I strapped in and created Rye code below. I think I only needed to add generic methods stat and size?, all other were already implemented, which is a good sign.



Of course, we are in an age of ChatGPT, so I used it to generate the equivalent  Python code. It used the elegant Flask framework to do it. If I ever wanted to serve something via HTTP with Python in last 10 years I also used Flask. It's nice and minimalistic.

I removed the comments above, and this are the Python and Rye examples side by side:


If we delve a little deeper into both examples, we notice that Rye example uses lower level concepts to serve the HTTP. 

  • Flask routes are determined by the decorator pattern over handler functions - Rye explicitly defines the routes on the server object.
  • Flask response is generated directly from the handler function return value and status code - Rye uses a response writer, that handler can use to set headers and write response content to.
  • Flask has a specialized function to return a binary file send_file (I assume without loading it into memory) - In Rye we manually set the correct headers and used a general IO function copy to copy file reader into response writer (also not loading the file into memory) ... it directly mimics the Go way.

And I think this is correct. Rye here uses it's basic language level functions which should be opinion-neutral and use generic lower level mechanisms that multiple opinionated higher level frameworks or libraries can then be built upon. 

I am not about to build a web-framework for this, but taking some inspiration from the Flask example, I saw I could make my little "nano-framework" by creating just two functions: respond and send-file

So after I made these two functions, Rye code becomes quite clean and nice:

And these two functions are simple and straightforward.


Ok. This is it. I hope you understood the examples. If you want the real code, not these screenshots please visit our Github repo and check out folder examples/webserver. 

I lately post regular development updates on Rye's reddit group, so please come by and become a member. :)

Komentarji

Objavite komentar

Priljubljene objave iz tega spletnega dnevnika

Receiving emails with Go's smtpd and Rye

This goes a while back. At some project for user support, we needed to receive emails and save them to appropriate databases. The best option back in the day seemed project Lamson . And it worked well ever since. It was written in Python by then quite known programmer Zed Shaw. It worked like a Python based SMTP server, that called your handlers when emails arrived. It was sort of Ruby on Rails for email. We were using this ever since. Now our system needs to be improved, there are still some emails or attachments that don't get parsed correctly. That isn't the problem of Lamson, but of our code that parses the emails. But Lamson development has been passive for more than 10 years. And I am already moving smaller utilities to Rye.  Rye uses Go, and Go has this nice library smtpd , which seems like made for this task. I integrated it and parsemail into Rye and tested it in the Rye console first. Interesting function here is enter-console , that can put you into Rye console any...
Objavite komentar
Preberite več

Go's concurrency in a dynamic language Rye

  The Rye programming language is a dynamic scripting language based on REBOL’s ideas, taking inspiration from the Factor language and Unix shell. Rye is written in Go and inherits Go’s concurrency capabilities, including goroutines and channels. Recently, Rye gained support for Go’s select and waitgroups. Building blocks Goroutines Goroutines are lightweight threads of execution that are managed by the Go/Rye runtime. They operate independently, allowing multiple tasks to run concurrently without blocking each other. Creating a Goroutine in Rye is straightforward. The go keyword is used to launch a new Goroutine, followed by the Rye function to be executed concurrently. For instance, the following code snippet creates and starts a Goroutine that prints a message after a delay: ; # Hello Goroutine print "Starting Goroutine" go does { ; does creates a function without arguments sleep 1000 print "Hello from Goroutine!" } print "Sleepi...
Objavite komentar
Preberite več