Update Spanish translation and Solve problem with invalid paths (#87)

* Add unofficial/unsupported installation methods.

* Update from_scratch.md

* Remove https: from .gitignore

* Translated client development section to ES.

* Include missing file for translation.

* Translation progress Contributing section.

* Add title.

* Translated contributing section to ES.

* Updated translation.

* Add missing file release_process.md

* Update websocket_api.md

* Add Troubleshooting section in README

* change `route` to `path`

* Translate from_scratch.md and on_aws.md. Update README

* Remove `espeak` mention from both EN and ES.
This commit is contained in:
mickie 2021-07-15 08:35:11 -05:00 committed by GitHub
parent 670802a905
commit d882fdbe81
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 712 additions and 220 deletions

View file

@ -26,7 +26,6 @@ I had to switch from using `sudo` to `su`'ing in some places as the user was doi
| dev-db | [postgresql](https://www.postgresql.org/) |
| www-servers | [nginx](https://nginx.org/en/) |
| sys-apps | [yarn](https://yarnpkg.com/) |
| (optional) app-accessibility | espeak |
| app-shells | bash-completion |

View file

@ -1 +1,2 @@
# [WebSocket API](https://join-lemmy.org/api/index.html)
# WebSocket API
[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)

View file

@ -1,3 +1,5 @@
# Local Development
### Install build requirements
Install Rust using [the recommended option on rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).

View file

@ -8,7 +8,8 @@
- [Administración](administration/administration.md)
- [Instalación con Docker](administration/install_docker.md)
- [Instalación con Ansible](administration/install_ansible.md)
- [Otros Métodos de Instalación](administration/other_installation_methods.md)
- [Instalar desde Cero](administration/from_scratch.md)
- [Instalar en AWS](administration/on_aws.md)
- [Configuración](administration/configuration.md)
- [Introducción a la Federación](administration/federation_getting_started.md)
- [Solución de Problemas](administration/troubleshooting.md)
@ -17,15 +18,16 @@
- [Visión General de la Federación](federation/overview.md)
- [Recursos](federation/resources.md)
- [Protocolo de Lemmy](federation/lemmy_protocol.md)
- [Client Development](client_development/client_development.md)
- [Theming Guide](client_development/theming.md)
- [API reference](client_development/api_reference.md)
- [WebSocket API](client_development/websocket_api.md)
- [HTTP API](client_development/http_api.md)
- [Creating a Custom Frontend](client_development/custom_frontend.md)
- [Contributing](contributing/contributing.md)
- [Docker Development](contributing/docker_development.md)
- [Local Development](contributing/local_development.md)
- [Tests](contributing/tests.md)
- [Federation Development](contributing/federation_development.md)
- [Desarrollo de clientes](client_development/client_development.md)
- [Guiá para Temas](client_development/theming.md)
- [Referencia de la API](client_development/api_reference.md)
- [API del WebSocket](client_development/websocket_api.md)
- [API HTTP](client_development/http_api.md)
- [Crear un Frontend Personalizado](client_development/custom_frontend.md)
- [Contribuir al Proyecto](contributing/contributing.md)
- [Desarrollo con Docker](contributing/docker_development.md)
- [Desarrollo Local](contributing/local_development.md)
- [Pruebas](contributing/tests.md)
- [Desarrollo de la Federación](contributing/federation_development.md)
- [Bifurcaciones y Liberaciones](contributing/release_process.md)
- [Código de Conducta](code_of_conduct.md)

View file

@ -3,9 +3,17 @@
Información para administradores de las instancias de Lemmy, y para aquellos que quieran gestionar un servidor.
## Instalación
### Métodos oficiales/soportados
Lemmy tiene dos métodos principales de instalación, [manual con Docker](install_docker.md), y [automatizado con Ansible](install_ansible.md). Recomendamos usar Ansible, porque simplifica la instalación y también facilita la actualización.
Lemmy tiene dos métodos principales de instalación:
- [Manual con Docker](install_docker.md)
- [Automatizado con Ansible](install_ansible.md).
## Otros métodos de instalación
Recomendamos usar Ansible, porque simplifica la instalación y también facilita la actualización.
En algunos casos, puede ser necesario utilizar [otros métodos de instalación](other_installation_methods.md). Pero no lo recomendamos y no podemos dar soporte para ellos.
### Otros métodos de instalación
> ⚠️ **Bajo tu propio riesgo.**
En algunos casos, puede ser necesario utilizar diferentes métodos de instalación. Pero no los recomendamos y no podemos dar soporte para ellos.
- [Instalar desde Cero](from_scratch.md)
- [En Amazon Web Services (AWS)](on_aws.md)

View file

@ -0,0 +1,394 @@
# Instalar desde Cero
> ⚠️ **Descargo de responsabilidad:** este método de instalación no está recomendado por los desarrolladores de Lemmy. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de este modo, por favor, menciónalo en el informe de fallos.
## Instalando Lemmy desde el código fuente
Instrucciones para instalar Lemmy de forma Nativa, sin depender de docker. Originalmente fue publicado en [Some resources on setting Lemmy up from source - Lemmy dot C.A.](https://lemmy.ca/post/1066) **La transcripción actual se ha adaptado para mejorar su legibilidad**.
### Importante
> Las referencias de los paquetes de software a continuación **son todas basadas en Gentoo** - Hay información en los archivos de docker sobre lo que se requiere en los sistemas tipo debian, y para cualquier otra cosa probablemente podrás ajustar fácilmente como sea necesario.
Ten en cuenta que la construcción de Lemmy requiere de una gran cantidad de recursos de hardware. Si quieres ejecutar Lemmy en un pequeño VPS con una memoria RAM muy limitada (que parece una forma perfectamente aceptable para ejecutar una instancia de producción), es mejor seguir con la imagen docker, o usar un sistema que tenga más RAM. El uso de RAM es enorme con las builds de Rust.
Las versiones de etiqueta/lanzamiento incluidas en esta nota provienen de lemmy/docker/prod/docker-compose.yml y estaban actualizadas en el momento en que se creó este documento. **Definitivamente ajustar a las versiones apropiadas como sea necesario**.
Tuve que cambiar de usar `sudo` a `su` en algunos lugares ya que el usuario estaba haciendo algo raro/incompleto con el env de sudo para pictrs
## Configuración
| Dependencias | |
|------------------------------|-------------------------------------------|
| app-admin | sudo |
| dev-vcs | [git](https://git-scm.com/) |
| dev-lang | [rust](https://www.rust-lang.org/) |
| dev-db | [postgresql](https://www.postgresql.org/) |
| www-servers | [nginx](https://nginx.org/en/) |
| sys-apps | [yarn](https://yarnpkg.com/) |
| app-shells | bash-completion |
| | |
### Poner en marcha el postgresql
```bash
emerge --config dev-db/postgresql
rc-service postgresql-12 start
useradd -m -s /bin/bash lemmy
cd ~lemmy
sudo -Hu lemmy git clone https://github.com/LemmyNet/lemmy.git
cd lemmy
```
### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
```bash
sudo -Hu lemmy git tag -l
sudo -Hu lemmy git checkout tags/v0.11.0
```
### Build para producción? (Remover --release para dev)
```bash
sudo -Hu lemmy cargo build --release
cd ..
sudo -Hu lemmy git clone https://github.com/LemmyNet/lemmy-ui.git
cd lemmy-ui
```
### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
```bash
sudo -Hu lemmy git tag -l
sudo -Hu lemmy git checkout tags/v0.8.10
sudo -Hu lemmy git submodule init
sudo -Hu lemmy git submodule update --remote
```
### Construir el frontend
#### Esto es para desarrollo
```bash
sudo -Hu lemmy yarn
```
#### Esto es para producción
```bash
sudo -Hu lemmy yarn install --pure-lockfile
sudo -Hu lemmy yarn build:prod
```
**Esto es solo para correr un entorno de desarrollo, pero creo que es preferible para producción - usar el script de inicio**
```bash
sudo -Hu lemmy yarn dev
```
Para producción, usaremos el [script de inicio](#initlemmy), pero el comando para producción es:
```bash
sudo -Hu node dist/js/server.js
```
### Configurar la base de datos
#### Ajustar la contraseña:
```bash
sudo -u postgres psql -c "create user lemmy with password 'password' superuser;" -U postgres
sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
```
### Instalar iFramely
Son requeridos git y nodejs, pero nodejs debe ser instalado como dependencia de yarn.
#### En caso de que iFramely sea instalado en otro sistema
```bash
useradd -m -s /bin/bash iframely
cd ~iframely
sudo -Hu iframely git clone https://github.com/itteco/iframely.git
cd iframely
sudo -Hu iframely git tag -l
sudo -Hu iframely git checkout tags/v1.5.0
sudo -Hu iframely npm install
```
**Opcional** Remplazar puerto 80 por 8061; también remplazar o desabilitar el almacenamiento del cache por ahora (CACHE_ENGINE: 'no-cache')
```bash
sudo -Hu iframely cp ~lemmy/lemmy/docker/iframely.config.local.js ~lemmy/iframely/config.local.js
```
Iniciar el servidor iframely o, usar un [script de inicio](#initiframely) en su lugar, el cual es la mejor opción que correr esto manualmente.
```bash
sudo -Hu iframely node server
```
### Instalar pict-rs
```bash
useradd -m -s /bin/bash pictrs
cp target/release/pict-rs .
```
Añadido **hdri** ya que **magick_rust** falla al compilar si no está. Mencionado en [error[E0425]: cannot find value QuantumRange in module bindings](https://github.com/nlfiedler/magick-rust/issues/40)
```bash
echo "media-gfx/imagemagick hdri jpeg lzma png webp" >> /etc/portage/package.use
echo "*/* -llvm_targets_NVPTX -llvm_targets_AMDGPU" >> /etc/portage/package.use
```
Instalar paquetes extra requeridos para pict-rs:
| Paquetes | |
|-------------|--------------------------------------------------|
| media-libs | [gexiv2](https://gitlab.gnome.org/GNOME/gexiv2) |
| media-gfx | [imagemagick](https://imagemagick.org/index.php) |
| media-video | [ffmpeg](https://ffmpeg.org/) |
| sys-devel | [clang](https://clang.llvm.org/) |
Paquetes requeridos para pict-rs (en caso de un sistema separado):
| Paquetes | |
|----------|------------------------------------|
| dev-lang | [rust](https://www.rust-lang.org/) |
**Opcional** Hacer un script o ejecutarlo manualmente como usuario.
```bash
su - pictrs
git clone https://git.asonix.dog/asonix/pict-rs.git
cd pict-rs
git tag -l
git checkout tags/v0.2.5-r0
cargo build --release
cp target/release/pict-rs .
cd ~pictrs
mkdir pictrs-data
```
**Falta algo en el README de pict-rs - creó y utilaza una carpeta pict-rs in /tmp**
Si haces algo raro como yo (cambiar el usuario con el que se ejecuta pict-rs) y terminas con problemas de permisos (que los registros no te dicen *Qué* está teniendo un problema de permisos), este podría ser tu problema. Además, el tiempo dirá si esta carpeta se limpia adecuadamente o no.
Ejecutar pictrs de acuerdo a la siguiente línea:
```bash
pict-rs/pict-rs -a 127.0.0.1:9000 -p ~pictrs/pictrs-data/
```
Pero sólo usaremos el script init.
En este punto, corre todo a través de los [scripts de inicio](#scripts-de-inicio-init-scripts). Configura los scripts de inicio para que se ejecuten en el tiempo de arranque. Presumiblemente has configurado nginx y puedes llegar a tu instancia.
---
## Actualizando
```bash
su - lemmy
cd lemmy
```
Haz BACKUP [config/config.hjson](#configuración-1) en algún lugar.
```bash
git fetch
git tag -l
git checkout tags/WHATEVER
cargo build --release
cd ~/lemmy-ui
```
### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
```bash
git fetch
git tag -l
git checkout tags/WHATEVER
git submodule update --remote
```
### Construir el frontend
#### Esto es para producción
```bash
yarn install --pure-lockfile # Is this step really needed?
#yarn upgrade --pure-lockfile # ?? Did I get it?
#yarn # Is this step really needed? One of these steps is for sure. (Should be unnecessary)
yarn build:prod
```
Reiniciar lemmy-ui
### Actualizar iFramely
```bash
su - iframely
cd iframely
git fetch
git tag -l
git checkout tags/v1.6.0 # Or whatever the current appropriate release is
npm install
```
Reinicia iframely
### Actualizar pict-rs
```bash
su - pictrs
cd pict-rs
git fetch
git tag -l
git checkout tags/v0.2.5-r0 # (or whatever is currently mentioned in the lemmy docker file)
cargo build --release
cp target/release/pict-rs .
```
Reinicia pictrs
---
## Índice
### configuración
ejemplo de config/config.hjson
```json
{
database: {
user: "lemmy"
password: "whatever"
host: "localhost"
port: 5432
database: "lemmy"
pool_size: 5
}
hostname: "lemmy.ca"
bind: "127.0.0.1"
port: 8536
docs_dir: "/home/lemmy/lemmy/docs/book"
pictrs_url: "http://localhost:9000"
iframely_url: "http://localhost:8061"
federation: {
enabled: true
allowed_instances: ""
blocked_instances: ""
}
email: {
smtp_server: "localhost:25"
smtp_from_address: "lemmy@lemmy.ca"
use_tls: false
}
}
```
### Scripts de inicio (init scripts)
##### init/iframely
```bash
#!/sbin/openrc-run
name="Iframely Daemon"
depend() {
need localmount
need net
}
start() {
ebegin "Starting Iframely"
start-stop-daemon --start --background --make-pidfile --user iframely --group iframely --pidfile /home/iframely/iframely.pid --chdir /home/iframely/iframely -3 /usr/bin/logger -4 /usr/bin/logger --exec node -- server
eend $?
}
stop() {
start-stop-daemon --stop --signal TERM --pidfile /home/iframely/iframely.pid
eend $?
}
```
##### init/lemmy
```bash
#!/sbin/openrc-run
name="Lemmy Backend"
depend() {
need localmount
need net
}
start() {
ebegin "Starting Lemmy"
start-stop-daemon --start --background --make-pidfile --user lemmy --group lemmy --pidfile /home/lemmy/lemmy.pid --chdir /home/lemmy/lemmy -3 /usr/bin/logger -4 /usr/bin/logger --exec ~lemmy/lemmy/target/release/lemmy_server
eend $?
}
stop() {
start-stop-daemon --stop --signal TERM --pidfile /home/lemmy/lemmy.pid
eend $?
}
```
##### init/lemmy-ui
```bash
#!/sbin/openrc-run
name="Lemmy UI"
depend() {
need localmount
need net
}
start() {
ebegin "Starting Lemmy UI"
start-stop-daemon --start --background --make-pidfile --user lemmy --group lemmy --pidfile /home/lemmy/lemmy-ui.pid --chdir /home/lemmy/lemmy-ui -3 /usr/bin/logger -4 /usr/bin/logger --exec node dist/js/server.js --env LEMMY_INTERNAL_HOST=127.0.0.1:8536 --env LEMMY_EXTERNAL_HOST=lemmy.ca --env LEMMY_HTTPS=true
eend $?
}
```
##### init/pict-rs
```bash
#!/sbin/openrc-run
name="pict-rs Daemon"
depend() {
need localmount
need net
}
start() {
ebegin "Starting pictrs"
start-stop-daemon --start --background --make-pidfile --user pictrs --group pictrs --pidfile /home/pictrs/pictrs.pid --chdir /home/pictrs/pict-rs -3 /usr/bin/logger -4 /usr/bin/logger --exec /home/pictrs/pict-rs/pict-rs -- -a 127.0.0.1:9000 -p ~pictrs/pictrs-data
eend $?
}
stop() {
start-stop-daemon --stop --signal TERM --pidfile /home/pictrs/pictrs.pid
eend $?
}
```

View file

@ -0,0 +1,53 @@
# Instalando en AWS
> ⚠️ **Descargo de responsabilidad:** este método de instalación no está recomendado por los desarrolladores de Lemmy. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de este modo, por favor, menciónalo en el informe de fallos.
## Lemmy AWS CDK
Contiene las definiciones de infraestructura necesarias para desplegar [Lemmy](https://github.com/LemmyNet/lemmy) en AWS su [Cloud Development Kit](https://docs.aws.amazon.com/cdk/latest/guide/home.html).
### Incluye:
* ECS fargate cluster
* Lemmy-UI
* Lemmy
* Pictrs
* IFramely
* CloudFront CDN
* Almacenamiento EFS para subir imágenes.
* Aurora Serverless Postgres DB
* Bastion VPC host
* Balanceadores de carga para Lemmy y IFramely
* Registros DNS para tu sitio.
## Inicio rápido
Clona el [Lemmy-CDK]( https://github.com/jetbridge/lemmy-cdk).
Clona [Lemmy](https://github.com/LemmyNet/lemmy) y [Lemmy-UI](https://github.com/LemmyNet/lemmy-ui) en el directorio de arriba.
```shell
cp example.env.local .env.local
# edit .env.local
```
Debes editar .env.local con la configuración de tu sitio.
```shell
npm install -g aws-cdk
npm install
cdk bootstrap
cdk deploy
```
## Coste
Esta *no* es la forma más barata de ejecutar Lemmy. La base de datos sin servidor (serverless) Aurora puede costarte ~$90/mes (en dólares) si no duerme.
## Comandos del CDK útiles
* `npm run build` compila typescript a js
* `npm run watch` vigila los cambios y compila
* `npm run test` realiza las pruebas unitarias de jest
* `cdk deploy` despliega esta pila en tu cuenta/región de AWS por defecto
* `cdk diff` compara la pila desplegada con el estado actual
* `cdk synth` emite la plantilla de CloudFormation sintetizada

View file

@ -1,15 +0,0 @@
# Otros Métodos de Instalación
**Descargo de responsabilidad:** los desarrolladores de Lemmy no recomiendan estos métodos de instalación. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de esta manera, menciónalo en el informe de fallos.
## Instalación de Lemmy sin Docker
Instrucciones para instalar Lemmy de forma nativa, sin depender de Docker.
[https://lemmy.ca/post/1066](https://lemmy.ca/post/1066)
## Instalación en Amazon Web Services (AWS)
Contiene las definiciones de infraestructura necesarias para desplegar Lemmy en [AWS](https://aws.amazon.com/) utilizando su [Kit de Desarrollo en la Nube](https://docs.aws.amazon.com/cdk/latest/guide/home.html).
[https://github.com/jetbridge/lemmy-cdk](https://github.com/jetbridge/lemmy-cdk)

View file

@ -1,49 +1,49 @@
# API reference
# Referencia de la API
Lemmy has two, intertwined APIs:
Lemmy tiene dos APIs entrelazadas:
- [WebSocket](https://join-lemmy.org/api/index.html)
- [HTTP](http_api.md)
This page describes concepts that are common to both.
Esta página describe conceptos que son comúnes para ambas.
<!-- toc -->
- [Basic usage](#basic-usage)
- [Data types](#data-types)
* [Lemmy types](#lemmy-types)
* [Lower-level types](#lower-level-types)
- [Default rate limits](#default-rate-limits)
- [Uso básico](#uso-básico)
- [Tipos de datos](#tipos-de-datos)
* [Tipos de Lemmy](#tipos-de-lemmy)
* [Tipos de bajo nivel](#tipos-de-bajo-nivel)
- [Límites de tarifa por defecto](#límites-de-tarifa-por-defecto)
<!-- tocstop -->
## Basic usage
## Uso básico
Request and response strings are in [JSON format](https://www.json.org).
Las cadenas de solicitud `request` y respuesta `response` están en [formato JSON](https://www.json.org/json-es.html).
## Data types
## Tipos de datos
### Lemmy types
### Tipos de Lemmy
- [Source tables, that have the columns / fields](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/source.ts)
- [Aggregates (for things like scores)](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/aggregates.ts)
- [Views - The main lemmy return types](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/views.ts)
- [Request Forms / Responses are in this folder](https://github.com/LemmyNet/lemmy-js-client/tree/main/src/interfaces/api)
- [tablas que tienen las columnas / campos](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/source.ts)
- [Aggregates (para cosas como las puntuaciones)](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/aggregates.ts)
- [Views (vistas) - The main lemmy return types](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/views.ts)
- [Los formularios de solicitud (Request) / respuesta (Responses)](https://github.com/LemmyNet/lemmy-js-client/tree/main/src/interfaces/api)
### Lower-level types
### Tipos de bajo nivel
- `?` designates an option which may be omitted in requests and not be present in responses. It will be of type ***SomeType***.
- `[SomeType]` is a list which contains objects of type ***SomeType***.
- Times and dates are timestamp strings in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format. Timestamps will be UTC, your client must do the UTC to local conversion.
- `?` designa una opción que puede omitirse en las solicitudes y no estar presenet en las respuestas. Será de tipo ***SomeType*** (AlgúnTipo).
- `[SomeType]` es una lista que contiene objetos del tipo ***SomeType***.
- Las horas (times) y fechas (dates) son cadenas de marcas de tiempo (timestamp) en formato [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Timestamps serán UTC, tú cliente debe hacer la conversión de UTC a local.
## Default rate limits
## Límites de tasa por defecto
These can be edited in your `lemmy.hjson` file, by copying the relevant section from [defaults.hjson](https://github.com/LemmyNet/lemmy/blob/main/config/defaults.hjson).
Estos límites pueden ser editados en tú archivo `lemmy.hjson`, copiando la sección relevante de [defaults.hjson](https://github.com/LemmyNet/lemmy/blob/main/config/defaults.hjson).
- 3 per hour for signups and community creation.
- 6 per hour for image posting.
- 6 per 10 minutes for post creation.
- 180 actions per minute for post voting and comment creation.
- 3 por hora para inscripciones y creación de comunidades.
- 6 por hora para publicación de imágenes.
- 6 por 10 minutos para la creación de publicaciones.
- 180 acciones por minuto para la votación de publicaciones y la creación de comentarios.
Everything else is not rate-limited.
El resto no cuenta con límites de tasa.
**See also:** [rate limiting for custom front-ends](custom_frontend.md#rate-limiting).
**Véase también:** [Limitación de la tasa para front-ends personalizados](custom_frontend.md#limitación-de-la-tasa).

View file

@ -1,6 +1,8 @@
# Client Development
# Desarrollo de clientes
- [Theming Guide](client_development/theming.md)
- [API reference](client_development/api_reference.md)
- [WebSocket API](https://join-lemmy.org/api/index.html)
- [HTTP API](client_development/http_api.md)
Esta sección es para cualquiera que quiera colaborar con la [aplicación web oficial para Lemmy](https://github.com/LemmyNet/lemmy-ui) o quiera desarrollar su propio cliente para el ecosistema Lemmy.
- [Guía para Temas](client_development/theming.md)
- [Referencia de la API](client_development/api_reference.md)
- [API del WebSocket](https://join-lemmy.org/api/index.html)
- [API HTTP](client_development/http_api.md)

View file

@ -1,14 +1,14 @@
# Creating a Custom Frontend
# Crear un Frontend Personalizado
The backend and frontend are completely decoupled, and run in independent Docker containers. They only communicate over the [Lemmy API](api_reference.md), which makes it quite easy to write alternative frontends.
El backend y el frontend están completamente desacoplados y se ejecutan en contenedores Docker independientes. Solo se comunican a través de la [API de Lemmy](api_reference.md), lo que hace que sea bastante fácil escribir interfaces alternativas.
This creates a lot of potential for custom frontends, which could change much of the design and user experience of Lemmy. For example, it would be possible to create a frontend in the style of a traditional forum like [phpBB](https://www.phpbb.com/), or a question-and-answer site like [stackoverflow](https://stackoverflow.com/). All without having to think about database queries, authentification or ActivityPub, which you essentially get for free.
Esto crea un gran potencial para las interfaces personalizadas, que podrían cambiar gran parte del diseño y la experiencia del usuario de Lemmy. Por ejemplo, sería posible crear un frontend al estilo de un foro tradicional como [phpBB](https://www.phpbb.com/), o un sitio de preguntas y respuestas como [stackoverflow](https://stackoverflow.com/). Todo ello sin tener que pensar en las consultas a la base de datos, en la autentificación o en el ActivityPub, que esencialmente se obtiene de forma gratuita.
## Development
## Desarrollo
You can use any language to create a custom frontend. The easiest option would be forking our [official frontend](https://github.com/LemmyNet/lemmy-ui), [lemmy-lite](https://github.com/IronOxidizer/lemmy-lite), or the [lemmy-frontend-example](https://github.com/LemmyNet/lemmy-front-end-example). In any case, the principle is the same: bind to `LEMMY_EXTERNAL_HOST` (default: `localhost:8536`) and handle requests using the Lemmy API at `LEMMY_INTERNAL_HOST` (default: `lemmy:8536`). Also use `LEMMY_HTTPS` to generate links with the correct protocol.
Puedes utilizar cualquier lenguaje para crear un frontend personalizado. La opción más fácil sería hacer un fork de nuestro [frontend oficial](https://github.com/LemmyNet/lemmy-ui), [lemmy-lite](https://github.com/IronOxidizer/lemmy-lite), o el [lemmy-frontend-example](https://github.com/LemmyNet/lemmy-front-end-example). En cualquier caso, el principio es el mismo: enlazar con `LEMMY_EXTERNAL_HOST` (por defecto: `localhost:8536`) y gestionar las peticiones utilizando la API de Lemmy en `LEMMY_INTERNAL_HOST` (por defecto: `lemmy:8536`). Utilice también `LEMMY_HTTPS` para generar enlaces con el protocolo correcto.
The next step is building a Docker image from your frontend. If you forked an existing project, it should already include a `Dockerfile` and instructions to build it. Otherwise, try searching for your language on [dockerhub](https://hub.docker.com/), official images usually have build instructions in their readme. Build a Docker image with a tag, then look for the following section in `docker/dev/docker-compose.yml`:
El siguiente paso es construir una imagen Docker desde tu frontend. Si has bifurcado (fork) un proyecto existente, debería incluir un archivo Docker y las instrucciones para construirlo. Si no, intenta buscar para tu lenguaje en [dockerhub](https://hub.docker.com/), las imágenes oficiales suelen tener instrucciones para construir en su readme. Construye una imagen Docker con una etiqueta, luego busca la siguiente sección en `docker/dev/docker-compose.yml`:
```
lemmy-ui:
@ -24,25 +24,25 @@ The next step is building a Docker image from your frontend. If you forked an ex
- lemmy
```
All you need to do is replace the value for `image` with the tag of your own Docker image (and possibly the environment variables if you need different ones). Then run `./docker_update.sh`, and after compilation, your frontend will be available on `http://localhost:1235`. You can also make the same change to `docker/federation/docker-compose.yml` and run `./start-local-instances.bash` to test federation with your frontend.
Todo lo que tienes que hacer es sustituir el valor de `image` por la etiqueta de tu propia imagen Docker (y posiblemente las variables de entorno si necesitas otras diferentes). A continuación, ejecuta `./docker_update.sh`, y después de la compilación, tu frontend estará disponible en `http://localhost:1235`. También puedes hacer el mismo cambio en `docker/federation/docker-compose.yml` y ejecutar `./start-local-instances.bash` para probar la federación con tu frontend.
## Deploy with Docker
## Desplegar con Docker
After building the Docker image, you need to push it to a Docker registry (such as [dockerhub](https://hub.docker.com/)). Then update the `docker-compose.yml` on your server, replacing the `image` for `lemmy-ui`, just as described above. Run `docker-compose.yml`, and after a short wait, your instance will use the new frontend.
Después de construir la imagen Docker, necesitas empujarla (hacer push) a un registro Docker (como [dockerhub](https://hub.docker.com/)). A continuación, actualiza el `docker-compose.yml` en tu servidor, sustituyendo la `image` por `lemmy-ui`, tal y como se ha descrito anteriormente. Ejecuta `docker-compose.yml` y, tras una breve espera, tu instancia utilizará el nuevo frontend.
Note, if your instance is deployed with Ansible, it will override `docker-compose.yml` with every run, reverting back to the default frontend. In that case you should copy the `ansible/` folder from this project to your own repository, and adjust `docker-compose.yml` directly in the repo.
Toma en cuenta que si tu instancia se despliega con Ansible, éste anulará (sobreescribirá) `docker-compose.yml` con cada ejecución, volviendo al frontend por defecto. En ese caso debes copiar la carpeta `ansible/` de este proyecto a tu propio repositorio, y ajustar `docker-compose.yml` directamente en el repo.
It is also possible to use multiple frontends for the same Lemmy instance, either using subdomains or subfolders. To do that, don't edit the `lemmy-ui` section in `docker-compose.yml`, but duplicate it, adjusting the name, image and port so they are distinct for each. Then edit your nginx config to pass requests to the appropriate frontend, depending on the subdomain or path.
También es posible utilizar varios frontends para la misma instancia de Lemmy, ya sea utilizando subdominios o subcarpetas. Para ello, no edites la sección `lemmy-ui` en `docker-compose.yml`, sino duplícala, ajustando el nombre, la imagen y el puerto para que sean distintos para cada uno. Luego edita tu configuración de nginx para pasar las peticiones al frontend apropiado, dependiendo del subdominio o la ruta.
## Translations
## Traducciones
You can add the [lemmy-translations](https://github.com/LemmyNet/lemmy-translations) repository to your project as a [git submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules). That way you can take advantage of same translations used in the official frontend, and you will also receive new translations contributed via weblate.
Puedes añadir el repositorio [lemmy-translations](https://github.com/LemmyNet/lemmy-translations) a tu proyecto como un [submódulo git](https://git-scm.com/book/en/v2/Git-Tools-Submodules). De este modo, podrás aprovechar las mismas traducciones que se utilizan en el frontend oficial, y también recibirás las nuevas traducciones aportadas a través de [weblate](https://weblate.org/es/).
## Rate limiting
## Limitación de la tasa
Lemmy does rate limiting for many actions based on the client IP. But if you make any API calls on the server side (eg in the case of server-side rendering, or javascript pre-rendering), Lemmy will take the IP of the Docker container. Meaning that all requests come from the same IP, and get rate limited much earlier. To avoid this problem, you need to pass the headers `X-REAL-IP` and `X-FORWARDED-FOR` on to Lemmy (the headers are set by our nginx config).
Lemmy limita la tasa de muchas acciones en función de la IP del cliente. Pero si haces alguna llamada a la API en el lado del servidor (por ejemplo, en el caso de la renderización del lado del servidor, o la pre-renderización de javascript), Lemmy tomará la IP del contenedor Docker. Lo que significa que todas las peticiones provienen de la misma IP, y obtienen la tasa limitada mucho antes. Para evitar este problema, es necesario pasar las cabeceras `X-REAL-IP` y `X-FORWARDED-FOR` a Lemmy (las cabeceras son establecidas por nuestra configuración de nginx).
Here is an example snipped for NodeJS:
Aquí hay un ejemplo recortado para NodeJS:
```javascript
function setForwardedHeaders(
@ -63,4 +63,4 @@ function setForwardedHeaders(
let headers = setForwardedHeaders(req.headers);
let client = new LemmyHttp(httpUri, headers);
```
```

View file

@ -1,35 +1,36 @@
# Lemmy HTTP API
# API HTTP de Lemmy
<!-- toc -->
- [Websocket vs HTTP API](#websocket-vs-http-api)
- [Examples](#examples)
- [Websocket vs API HTTP](#websocket-vs-api-http)
- [Ejemplos](#ejemplos)
* [TypeScript](#typescript)
* [Curl](#curl)
+ [GET](#get-example)
+ [POST](#post-example)
- [HTTP API exclusive features](#http-api-exclusive-features)
+ [GET](#ejemplo-get)
+ [POST](#ejemplo-post)
- [Características exclusivas de la API HTTP](#características-exclusivas-de-la-api-http)
* [RSS/Atom feeds](#rss-atom-feeds)
* [Images](#images)
+ [Create (request)](#create-request)
+ [Create (response)](#create-response)
* [Imagenes](#imagenes)
+ [Crear (request)](#crear-request)
+ [Crear (response)](#crear-response)
* [Delete](#delete)
<!-- tocstop -->
## WebSocket vs HTTP API
Lemmy's HTTP API is almost identical to its WebSocket API:
- **WebSocket API** needs `let send = { op: userOperation[op], data: form}` as shown in [the WebSocketAPI specification](https://join-lemmy.org/api/index.html)
- **HTTP API** needs the form (data) at the top level, an HTTP operation (GET, PUT or POST) and endpoint (at `http(s)://host/api/v2/endpoint`). For example:
## WebSocket vs API HTTP
La API HTTP de Lemmy es casi parecida a la API del Websocket:
- **API WebSocket** necesita `let send = { op: userOperation[op], data: form}` como se muestra en [la especificación de la API WebSocket](https://join-lemmy.org/api/index.html)
- **API HTTP** necesita el formulario (datos) en el primer nivel; una operación HTTP (GET, PUT o POST) y endpoint (en `http(s)://host/api/v2/endpoint`). Por ejemplo:
> `POST {username_or_email: X, password: X}`
For more information, see the [http.ts](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) file.
Para más información. Véase el archivo
[http.ts](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) .
[The WebSocket API](https://join-lemmy.org/api/index.html) should be regarded as the primary source for the HTTP API since it also provides information about how to form HTTP API calls.
[El API del WebSocket](https://join-lemmy.org/api/index.html) debería considerarse como la fuente principal para la API HTPP, ya que también proporciona información sobre cómo formular las llamadas a la API HTTP.
## Examples
## Ejemplos
### TypeScript
@ -39,19 +40,19 @@ For more information, see the [http.ts](https://github.com/LemmyNet/lemmy-js-cli
}
```
| Type | URL | Body type | Return type |
| Tipo | URL | Tipo de cuerpo | Tipo de Retorno |
| --- | --- | --- | --- |
| `PUT` | `/comment` | `EditComment` | `CommentResponse` |
### Curl
**GET example**
#### Ejemplo GET
```
curl "http://localhost:8536/api/v2/community/list?sort=Hot"`
```
**POST example**
#### Ejemplo POST
```
curl -i -H \
@ -65,34 +66,36 @@ curl -i -H \
http://localhost:8536/api/v2/comment/like
```
## HTTP API exclusive features
## Características exclusivas de la API HTTP
These features cannot be accessed from the WebSocket API:
Estas características no pueden ser accesadas desde la API del WebSocket:
- [RSS/Atom feeds](#rss-atom-feeds)
- [Images](#images)
- [Imagenes](#imagenes)
### RSS/Atom feeds
- All - `/feeds/all.xml?sort=Hot`
- Community - `/feeds/c/community-name.xml?sort=Hot`
- User - `/feeds/u/user-name.xml?sort=Hot`
- All (Todo) - `/feeds/all.xml?sort=Hot`
- Community (Comunidad) - `/feeds/c/community-name.xml?sort=Hot`
- User (usuario) - `/feeds/u/user-name.xml?sort=Hot`
### Images
### Imagenes
Lemmy forwards image requests to a locally running Pictrs.
Leemy reenvía las peticiones de imagenes a un Pictrs que se ejecuta localmenet.
`GET /pictrs/image/{filename}?format={webp, jpg, ...}&thumbnail={96}`
*Format and thumbnail are optional.*
*El formato (format) y la miniatura (thumbnail) son opcionales*
#### Create (request)
#### Crear (request)
El contenido subido debe ser un formulario (multipart/form-data) válido con una matriz de imagenes situada dentro de la clave `images[]`.
Uploaded content must be valid multipart/form-data with an image array located within the images[] key.
`POST /pictrs/image`
#### Create (response)
#### Crear (response)
```
{
@ -111,6 +114,7 @@ Uploaded content must be valid multipart/form-data with an image array located w
`GET /pictrs/image/delete/{delete_token}/{file}`
# Note
# Nota
This documentation may lag behind the actual [API endpoints](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) and the API itself should be considered unstable (since it may change at any time).
Esta documentación puede tener un retraso con respecto a la actual
[API endpoints](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts). La API misma debería ser considerada inestable (está sujeta a cambios en cualquier momento).

View file

@ -1,19 +1,19 @@
# Theming Guide
# Guía para Temas
Lemmy uses [Bootstrap v4](https://getbootstrap.com/), and very few custom css classes, so any bootstrap v4 compatible theme should work fine.
Lemmy usa [Bootstrap v4](https://getbootstrap.com/), y algunas clases css customizadas por lo que cualquier tema compatible con bootstrap v4 debería de funcionar.
## Creating
## Creación
- Use a tool like [bootstrap.build](https://bootstrap.build/) to create a bootstrap v4 theme. Export the `bootstrap.min.css` once you're done, and save the `_variables.scss` too.
- Usa una herramienta, por ejemplo [bootstrap.build](https://bootstrap.build/) para crear tú tema de bootstrap v4. Exporta el archivo `bootstrap.min.css` una vez terminado el tema, y conserva támbién el archivo generado `_variables.scss`.
## Testing
## Prueba
- To test out a theme, you can either use your browser's web tools, or a plugin like stylus to copy-paste a theme, when viewing Lemmy.
- Para probar el tema, puedes también usar las herramientas del navegador web, o un plugin como *stylus* para copiar/pegar un tema, y verlo en Lemmy.
## Adding
## Subir / Publicar
1. Fork the [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
1. Copy `{my-theme-name}.min.css` to `src/assets/css/themes`. (You can also copy the `_variables.scss` here if you want).
1. Go to `src/shared/utils.ts` and add `{my-theme-name}` to the themes list.
1. Test locally
1. Do a pull request with those changes.
1. Haz un *fork* de [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
1. Copia el archivo `{nombre-de-mi-tema}.min.css` a la carpeta `src/assets/css/themes`. (Aquí puedes copiar el archivo `_variables.scss` si lo deseas).
1. Abre el archivo `src/shared/utils.ts` y agregas `{nombre-de-mi-tema}` a la lista de temas.
1. Pruebalo localmente
1. Haz *pull request* con los cambios que hiciste.

View file

@ -1 +1,2 @@
# [WebSocket API](https://join-lemmy.org/api/index.html)
# API del WebSocket
[Documentación de la API del WebSocket de Lemmy](https://join-lemmy.org/api/index.html)

View file

@ -1,40 +1,39 @@
# Contributing
# Contribuir al Proyecto
Information about contributing to Lemmy, whether it is translating, testing, designing or programming.
Información sobre como contribuir a Lemmy, ya sea traduciendo, probando, diseñando o programando.
## Issue tracking / Repositories
## Seguimiento de problemas (issues) / Repositorios
- [GitHub (for issues and pull requests)](https://github.com/LemmyNet/lemmy)
- [Gitea (only for pull requests)](https://yerbamate.ml/LemmyNet/lemmy)
- [GitHub (para issues y pull requests)](https://github.com/LemmyNet/lemmy)
- [Gitea (solo para pull requests)](https://yerbamate.ml/LemmyNet/lemmy)
- [Codeberg](https://codeberg.org/LemmyNet/lemmy)
## Translating
## Traduciendo
Check out [Lemmy's Weblate](https://weblate.yerbamate.ml/projects/lemmy/) for translations. You can also help by [translating this documentation](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
Mira el [Weblate de Lemmy](https://weblate.yerbamate.ml/projects/lemmy/) para las traducciones. Tú también puedes ayudar [traduciendo esta documentación](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
## Architecture
## Arquitectura
### Front end
- The front end is written in `typescript`, using a react-like framework called [inferno](https://infernojs.org/). All UI elements are reusable `.tsx` components.
- The front end repository is [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
- The routes are at `src/shared/routes.ts`.
- The components are located in `src/shared/components`.
- El front end está escrito en `typescript`, usando un framework similar a React llamado [inferno](https://infernojs.org/). Todos los elementos de la interfaz de usuario (UI) son componentes `.tsx` reutilizables.
- El repositorio del front end es [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
- Las rutas están en `src/shared/routes.ts`.
- Los componentes están localizados en `src/shared/components`.
### Back end
- The back end is written in `rust`, using `diesel`, and `actix`.
- The server source code is split into main sections in `src`. These include:
- `db` - The low level database actions.
- Database additions are done using diesel migrations. Run `diesel migration generate xxxxx` to add new things.
- `api` - The high level user interactions (things like `CreateComment`)
- `routes` - The server endpoints .
- `apub` - The activitypub conversions.
- `websocket` - Creates the websocket server.
- El back end está escrito en `rust`, usando `diesel`, y `actix`.
- El código fuente del servidor está divido en secciones *main* in `src`. Estos incluyen:
- `db` - Las acciones de bajo nivel de la base de datos.
- Las adiciones a la base de datos se realizan mediante migraciones. Ejecuta `diesel migration generate xxxxx` para añadir cosas nuevas.
- `api` - Las iteracciones de alto nivel del usuario (cosas como `CreateComment`)
- `routes` - Los puntos finales (endpoints) del servidor.
- `apub` - Las conversiones activitypub.
- `websocket` - Crea el sevidor del websocket.
## Linting / Formatting
## Linting / Formateo
- Every front and back end commit is automatically formatted then linted using `husky`, and `lint-staged`.
- Rust with `cargo fmt` and `cargo clippy`.
- Typescript with `prettier` and `eslint`.
- Cada commit del front end y back end se formatea automáticamente y luego se hace un linting usando `husky`, y `lint-staged`.
- Rust con `cargo fmt` y `cargo clippy`.
- Typescript con `prettier` y `eslint`.

View file

@ -1,6 +1,8 @@
# Docker Development
# Desarrollo con Docker
## Dependencies (on Ubuntu)
## Dependencias
### Distro basada en Debian
```bash
sudo apt install git docker-compose
@ -8,18 +10,26 @@ sudo systemctl start docker
git clone https://github.com/LemmyNet/lemmy
```
## Running
### Distro basada en Arch
```bash
sudo -S git docker-compose
sudo systemctl start docker
git clone https://github.com/LemmyNet/lemmy
```
## Ejecución
```bash
cd docker/dev
./docker_update.sh
```
and go to http://localhost:1235.
Finalmente abre la siguiente dirección en tu navegador: `http://localhost:1235`.
*Note: many features (like docs and pictures) will not work without using an nginx profile like that in `ansible/templates/nginx.conf`.
**Nota:** muchas características (como docs e imagenes) no funcionarán sin usar un perfil de nginx como en `ansible/templates/nginx.conf`.
To speed up the Docker compile, add the following to `/etc/docker/daemon.json` and restart Docker.
Para acelerar la compilación de Docker, añade el siguiente código a `/etc/docker/daemon.json` y reinicia Docker.
```
{
"features": {
@ -28,5 +38,4 @@ To speed up the Docker compile, add the following to `/etc/docker/daemon.json` a
}
```
If the build is still too slow, you will have to use a
[local build](local_development.md) instead.
Si la compilación sigue siendo muy lenta, tendrás que usar un [desarrollo local](local_development.md) en su lugar.

View file

@ -1,43 +1,41 @@
# Federation Development
# Desarrollo de la Federación
## Running locally
## Ejecutando localmente
Install the dependencies as described in [Docker development](docker_development.md). Then run the following
Instala las dependencias necesarias como esta descrito en el documento [Desarrollo con Docker](docker_development.md). Enseguida ejecuta lo siguiente:
```bash
cd docker/federation
./start-local-instances.bash
```
The federation test sets up 5 instances:
Las pruebas de federación establecen 5 instancias:
Instance | Username | Location | Notes
Instancia | Nombre de usuario | Localización | Notas
--- | --- | --- | ---
lemmy-alpha | lemmy_alpha | [127.0.0.1:8540](http://127.0.0.1:8540) | federated with all other instances
lemmy-beta | lemmy_beta | [127.0.0.1:8550](http://127.0.0.1:8550) | federated with all other instances
lemmy-gamma | lemmy_gamma | [127.0.0.1:8560](http://127.0.0.1:8560) | federated with all other instances
lemmy-delta | lemmy_delta | [127.0.0.1:8570](http://127.0.0.1:8570) | only allows federation with lemmy-beta
lemmy-epsilon | lemmy_epsilon | [127.0.0.1:8580](http://127.0.0.1:8580) | uses blocklist, has lemmy-alpha blocked
lemmy-alpha | lemmy_alpha | [127.0.0.1:8540](http://127.0.0.1:8540) | federada con todas las demás instancias
lemmy-beta | lemmy_beta | [127.0.0.1:8550](http://127.0.0.1:8550) | federada con todas las demás instancias
lemmy-gamma | lemmy_gamma | [127.0.0.1:8560](http://127.0.0.1:8560) | federada con todas las demás instancias
lemmy-delta | lemmy_delta | [127.0.0.1:8570](http://127.0.0.1:8570) | solo permite federación con lemmy-beta
lemmy-epsilon | lemmy_epsilon | [127.0.0.1:8580](http://127.0.0.1:8580) | usa la lista de bloqueo, tiene lemmy-alpha bloqueada
You can log into each using the instance name, and `lemmy` as the password, IE (`lemmy_alpha`, `lemmy`).
Puedes registrarte en cada una usando el nombre de la instancia, y `lemmy` como la contraseña, ejemplo: (`lemmy_alpha`, `lemmy`).
To start federation between instances, visit one of them and search for a user, community or post, like this. Note that
the Lemmy backend runs on a different port than the frontend, so you have to increment the port number from
the URL bar by one.
Para iniciar la federación entre instancias, visita una de ellas y busca un
usuario, comunidad o publicación, como en este ejemplo. Nota que el backend de Lemmy se ejecuta en un puerto diferente al del frontend, por lo que tienes que incrementar en uno el número de puerto de la barra de URL.
- `!main@lemmy-alpha:8541`
- `http://lemmy-beta:8551/post/3`
- `@lemmy-gamma@lemmy-gamma:8561`
Firefox containers are a good way to test them interacting.
Los contenedores de Firefox son una buena forma de probar su interacción.
## Running on a server
## Ejecutando en un servidor
Note that federation is currently in alpha. **Only use it for testing**, not on any production server, and be aware that turning on federation may break your instance.
Ten en cuenta que la federación está actualmente en fase alfa. **Únicamente utilícela para pruebas**, no en un servidor de producción, y sé cuidadoso, que activar la federación puede romper tu instancia.
Follow the normal installation instructions, either with [Ansible](../administration/install_ansible.md) or
[manually](../administration/install_docker.md). Then replace the line `image: dessalines/lemmy:v0.x.x` in
`/lemmy/docker-compose.yml` with `image: dessalines/lemmy:federation`. Also add the following in
`/lemmy/lemmy.hjson`:
Sigue las instrucciones normales de instalación, ya sea con [Ansible](../administration/install_ansible.md) o
[manualmente con Docker](../administration/install_docker.md). Luego reemplaza la linea `image: dessalines/lemmy:v0.x.x` en
`/lemmy/docker-compose.yml` con `image: dessalines/lemmy:federation`. También añade lo siguiente en `/lemmy/lemmy.hjson`:
```
federation: {
@ -47,7 +45,7 @@ Follow the normal installation instructions, either with [Ansible](../administra
}
```
Afterwards, and whenever you want to update to the latest version, run these commands on the server:
Después, y siempre que quieras actualizar a la última versión, ejecuta estos comandos en el servidor:
```
cd /lemmy/
@ -55,15 +53,10 @@ sudo docker-compose pull
sudo docker-compose up -d
```
## Security Model
## Modelo de seguridad
- HTTP signature verify: This ensures that activity really comes from the activity that it claims
- check_is_apub_valid : Makes sure its in our allowed instances list
- Lower level checks: To make sure that the user that creates/updates/removes a post is actually on the same instance as that post
- Verificación de la firma HTTP: Garantiza que la actividad proviene realmente de la actividad que afirma
- check_is_apub_valid : Asegura que está en nuestra lista de instancias permitidas
- Comprobaciones de nivel inferior: Para asegurarse de que el usuario que crea/actualiza/elimina una publicación está realmente en la misma instancia que esa publicación
For the last point, note that we are *not* checking whether the actor that sends the create activity for a post is
actually identical to the post's creator, or that the user that removes a post is a mod/admin. These things are checked
by the API code, and its the responsibility of each instance to check user permissions. This does not leave any attack
vector, as a normal instance user cant do actions that violate the API rules. The only one who could do that is the
admin (and the software deployed by the admin). But the admin can do anything on the instance, including send activities
from other user accounts. So we wouldnt actually gain any security by checking mod permissions or similar.
Para el último punto, ten en cuenta que *no* estamos comprobando si el actor que envía la actividad de creación para una publicación es realmente idéntico al creador de la publicación, o si el usuario que elimina una entrada es un mod/admin. Estas cosas se comprueban por el código de la API, y es responsabilidad de cada instancia comprobar los permisos de los usuarios. Esto no deja ningún vector de ataque, ya que un usuario normal de la instancia no puede realizar acciones que violen las reglas de la API. El único que podría hacerlo es el administrador (y el software desplegado por el administrador). Pero el administrador puede hacer cualquier cosa en la instancia, incluso enviar actividades desde otras cuentas de usuario. Así que en realidad no ganaríamos nada de seguridad comprobando los permisos de los mods o similares.

View file

@ -1,5 +1,9 @@
### Install build requirements
#### Ubuntu
# Desarrollo Local
### Instalar requisitos
Instala Rust utilizando [la opción recomendada en rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).
#### Distro basada en Debian
```
sudo apt install git cargo libssl-dev pkg-config libpq-dev yarn curl gnupg2 espeak
# install yarn
@ -8,38 +12,42 @@ echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/source
sudo apt update && sudo apt install yarn
```
#### Distro basada en Arch
```
sudo pacman -S git cargo libssl-dev pkg-config libpq-dev yarn curl gnupg2 espeak
# install yarn (stable)
curl -o- -L https://yarnpkg.com/install.sh | bash
```
#### macOS
Instala [Homebrew](https://brew.sh/) si aún no lo has instalado.
Install Rust using [the recommended option on rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).
Then, install [Homebrew](https://brew.sh/) if you don't already have it installed.
Finally, install Node and Yarn.
Finalmente, instala Node y Yarn.
```
brew install node yarn
```
### Get the back end source code
### Obtener el código fuente del back end
```
git clone https://github.com/LemmyNet/lemmy.git
# or alternatively from gitea
# git clone https://yerbamate.ml/LemmyNet/lemmy.git
```
### Build the backend (Rust)
### Compila el backend (Rust)
```
cargo build
# for development, use `cargo check` instead)
# para desarrollo, usa `cargo check` en su lugar)
```
### Get the front end source code
### Obtener el código fuente del front end
```
git clone https://github.com/LemmyNet/lemmy-ui.git --recurse-submodules
```
### Setup postgresql
#### Ubuntu
### Configurar postgresql
#### Distro basada en Debian
```
sudo apt install postgresql
sudo systemctl start postgresql
@ -50,6 +58,17 @@ sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
```
#### Distro basada en Arch
```
sudo pacman -S postgresql
sudo systemctl start postgresql
# Either execute db-init.sh, or manually initialize the postgres database:
sudo -u postgres psql -c "create user lemmy with password 'password' superuser;" -U postgres
sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
```
#### macOS
```
brew install postgresql
@ -62,15 +81,15 @@ psql -c 'create database lemmy with owner lemmy;' -U postgres
export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
```
### Run a local development instance
### Ejecutar una instancia de desarrollo local
```
cd lemmy
cargo run
```
Then open [localhost:1235](http://localhost:1235) in your browser. To reload back-end changes, you will have to rerun `cargo run`. You can use `cargo check` as a faster way to find compilation errors.
Después abre [localhost:1235](http://localhost:1235) en tu navegador. Para recargar los cambios en el back-end, tendrás que volver ejecutar `cargo run`. Puedes usar `cargo check` como una manera mas rapida de econtrar errores de compilación.
To do front end development:
Para hacer desarrollo front end:
```
cd lemmy-ui
@ -78,8 +97,6 @@ yarn
yarn dev
```
and go to [localhost:1234](http://localhost:1234). Front end saves should rebuild the project.
Enseguida entra a [localhost:1234](http://localhost:1234). Al guardar cambios, el frond end se debe recargar automáticamenete.
Note that this setup doesn't include image uploads or link previews (provided by pict-rs and
iframely respectively). If you want to test those, you should use the
[Docker development](docker_development.md).
Toma en cuenta que esta configuración no incluye la carga de imagenes ni la previsualización de enlaces (proporcionada por pict-rs y iframely respectivamente). Si quieres probarlos, debes de usar el [desarrollo Docker](docker_development.md).

View file

@ -0,0 +1,19 @@
# Bifurcaciones y Liberaciones
## Bifurcaciones
En general, nuestro manejo de las ramas es el descrito en [Un modelo de bifurcación de líneal principal estable para Git](https://www.bitsnbites.eu/a-stable-mainline-branching-model-for-git/). Una diferencia es que evitamos el rebase `rebase`, y en su lugar fusionamos `merge` la rama base en la rama de trabajo actual. Esto ayuda a evitar empujes `push` forzados y conflictos.
## Liberaciones
- Para una versión mayo `major release`: crea una nueva rama `release/v0.x`
- Para una versión menor `minor release`: selecciona los cambios deseados en la rama `release/v0.x`
- Hacer una versión beta `beta` o candidata `release candidate` con `docker/prod/deploy.sh`
- Hacer lo mismo para `lemmy-ui`: `./deploy.sh 0.x.0-rc-x`
- Despliega en las instancias de prueba de la federación
- Mantener una instancia en la última versión estable para probar la compatibilidad de la federación (automatizar esto con ansible)
- `ansible-playbook -i federation playbooks/site.yml --vault-password-file vault_pass -e rc_version=0.x.0-rc.x`
- Prueba que todo funciona como se espera, haz nuevas versiones beta/rc si es necesario
- Despliega en lemmy.ml, para descubrir los problemas restantes
- Si todo ha ido bien, haz la versión oficial `0.x.0` con `docker/prod/deploy.sh`
- Anuncia el lanzamiento en Lemmy, Matrix, Mastodon

View file

@ -1,18 +1,17 @@
### Tests
### Pruebas
#### Rust
After installing [local development dependencies](local_development.md), run the
following commands:
Después de instalar las [dependencias para el desarrollo local](local_development.md), ejecuta el siguiente comando:
```bash
psql -U lemmy -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
./test.sh
```
### Federation
### Federación
Install the [Local development dependencies](local_development.md), and add the following lines to `/etc/hosts`:
Instala las [dependencias para el desarrollo local](local_development.md), y agrega las siguientes a `/etc/hosts`:
```
127.0.0.1 lemmy-alpha
@ -22,7 +21,8 @@ Install the [Local development dependencies](local_development.md), and add the
127.0.0.1 lemmy-epsilon
```
Then use the following script to run the tests:
Después usa el siguiente script para correr las pruebas:
```
cd api_tests
./run-federation-test.bash

View file

@ -0,0 +1,2 @@
# Federación

View file

@ -1 +1,2 @@
# [WebSocket API](https://join-lemmy.org/api/index.html)
# WebSocket API
[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)

View file

@ -1 +1,2 @@
# [WebSocket API](https://join-lemmy.org/api/index.html)
# WebSocket API
[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)