Spyke

Syndicated from the fediverse. Read and engage on the original instance.

View original on lemmy.ml
learningrustandlemmy·Learning Rust and Lemmybymaegul (he/they)

[GENERAL DISCUSSION] What is the general architecture/structure of the Lemmy code base?

The idea here is that this is a general discussion mega thread style post. Feel free to come in and ask questions, answer questions, and generally discuss.

This can go on as long as we want, and stay pinned if that works. We can simply using sorting to see the latest or "biggest" comments in here.

The worst bit about digging into a codebase, IMO, is orientating yourself and working out what does what!

The backend codebase can be found here: https://github.com/LemmyNet/lemmy

The "Contributing" section of the documentation (see here) lists how the other components of the platform interact with each other and the backend. But I don't think there's any outline of how the pieces of the backend work.

Perhaps another relevant codebase is the activity pub framework made along with lemmy: https://github.com/LemmyNet/activitypub-federation-rust.

View original on lemmy.ml
19
Comments2

2 replies

nmtake
lemm.ee

Hi, thanks for setting up this community. I'm not a Lemmy source contributer but I like to read open sources. Here is a very simplified web application (including Lemmy) architecture overview and I hope this text helps for some newbies:

  1. A user agent (web browser, mobile app, etc.) sends an HTTP request to a Lemmy instance.
  2. The lemmy instance examines the HTTP request and dispatches the request to a relevant function called controller. The mapping from a path in the URL to a function is called a router - see https://github.com/LemmyNet/lemmy/blob/0.19.3/src/api_routes_http.rs for example.
  3. The controller makes an HTTP response for the request and returns it to the user agent.
  4. The user agent displays the returned response to the user.

To find an controller from a path in the router, just grep (or a similar search function you use) the Lemmy source. For example, if I want to know how GET /user/export_settings works, I'll run these commands:

$ git clone https://github.com/LemmyNet/lemmy/  # if you haven't download the source yet
$ cd lemmy
$ rg export_settings
src/api_routes_http.rs
131:  user_settings_backup::{export_settings, import_settings},
274:        web::resource("/user/export_settings")
276:          .route(web::get().to(export_settings)),

crates/apub/src/api/user_settings_backup.rs
68:pub async fn export_settings(
301:  use crate::api::user_settings_backup::{export_settings, import_settings};
366:    let backup = export_settings(export_user.clone(), context.reset_request_count()).await?;
402:    let mut backup = export_settings(export_user.clone(), context.reset_request_count()).await?;

So we got the relevant route and the controller definitions very quickly. Settings to be exported are defined as a struct UserSettingsBackup. The controller is defined as pub async fn export_settings and it converts the struct to a JSON.

Rust might not be a easy programming language but the official text (calld The Book is very friendly for newbies, so don't hesitate to read and to write a simple program like guessing game.

12

You reached the end

[GENERAL DISCUSSION] What is the general architecture/structure of the Lemmy code base? | Spyke