Update projects

.gitignore

@@ -15,3 +15,4 @@ package-lock.json
 assets/css/notpurged
 purgecss.txt
 _includes/dummy.html
+git_commit_upstream.txt

_projects/asyncreq.md

@@ -0,0 +1,74 @@
+---
+layout: page
+title: calpkgs
+description: A lightweight Python library for making asynchronous HTTP requests.
+github: https://git.slc.ar/slococo/asyncreq
+importance: 6
+category: personal
+---
+
+This library provides two convenient methods for interacting with RESTful APIs in an asynchronous manner.
+
+## Installation
+
+To install the library, use the following pip command:
+
+```bash
+pip install asyncreq
+```
+
+## Usage
+
+### `make_request`
+
+The `make_request` method allows you to make asynchronous HTTP requests with flexible options. Here's an example of how to use it:
+
+```python
+from asyncreq import make_request
+
+async def example_usage():
+    url = "https://api.example.com/resource"
+    method = "GET"
+    headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}
+    
+    try:
+        response_data, status_code, response_headers = await make_request(
+            url=url,
+            method=method,
+            headers=headers,
+            # Add other optional parameters as needed
+        )
+        print(f"Response Data: {response_data}")
+        print(f"Status Code: {status_code}")
+        print(f"Response Headers: {response_headers}")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+```
+
+### `request`
+
+The `request` method is a simplified wrapper around `make_request` with added error handling. It raises appropriate exceptions for common HTTP-related errors:
+
+```python
+from asyncreq import request, HTTPException
+
+async def example_usage():
+    url = "https://api.example.com/resource"
+    method = "GET"
+    headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}
+    
+    try:
+        response_data, status_code, response_headers = await request(
+            url=url,
+            method=method,
+            headers=headers,
+            # Add other optional parameters as needed
+        )
+        print(f"Response Data: {response_data}")
+        print(f"Status Code: {status_code}")
+        print(f"Response Headers: {response_headers}")
+    except HTTPException as e:
+        print(f"An HTTP error occurred: {e}")
+```
+
+Note: make sure to use `await` as demonstrated in the examples above.

_projects/calsais.md

@@ -7,12 +7,12 @@ importance: 1
 category: personal
 ---
 
-### Usage
+## Usage
 
 Run
 
 ```
-curl -LO calsais.slococo.com.ar
+curl -LO slc.ar/calsais
 ```
 
 and then
@@ -21,6 +21,11 @@ and then
 sh calsais
 ```
 
-You can use `-d`, `-f` or `-s` to enable logging.
+You can use the following parameters:
+
+- `-d`: Print logs to both STDOUT and `calsais.log` file.
+- `-f`: Print logs only to the `calsais.log` file.
+- `-s`: Print logs only to STDOUT.
+- `-p`: Install `cdotfis` (personal dotfiles).
 
 The script only supports UEFI boot mode.

_projects/fids.md

@@ -0,0 +1,25 @@
+---
+layout: page
+title: fids
+description: Flight Information Display System
+importance: 2
+github: https://git.slc.ar/slococo/fids
+category: university
+---
+
+### Overview
+
+The FIDS (Flight Information Display System) project adopts a microservices architecture, comprising a collection of independently deployable services, each fulfilling specific functionalities within the system. The services `auth-domain`, `browser-domain`, `flights-domain`, `screens-domain`, `subscription-domain`, and `gateway`, work together to handle different tasks such as user authentication, displaying flight details, managing subscriptions, and connecting to other systems.
+
+### Objective
+
+The main goal of the FIDS project is to create a system that can handle flight information and user interactions smoothly. With a microservices architecture, each part of the system can be developed, deployed, and scaled independently, making it easier to adapt to changing needs.
+
+### Key features
+
+- **Microservices setup:** using microservices makes the FIDS system flexible and fast. Each service can be worked on and updated separately, which speeds up development and deployment.
+- **User-friendly design:** services like `browser-domain` and `screens-domain` are designed with users in mind, providing interfaces tailored to different types of users. This makes the system easier and more pleasant to use.
+- **Flight info management:** the `flights-domain` service handles all aspects of flight information, making sure data is accurate and up-to-date.
+- **Offline capability:** the `screens-domain` service lets users access cached flight info even when they're not connected to the internet, which is handy in places like airports where connections can be unreliable.
+- **Subscription management:** the `subscription-domain` service makes it easy for users to manage their subscriptions and get notifications, which helps keep them engaged with the system.
+- **Secure API access:** the `gateway` service acts as the central gateway for accessing the system's services securely. It also makes sure that only authorized users can access the system, keeping everything safe.

_projects/kube-exam.md

@@ -0,0 +1,19 @@
+---
+layout: page
+title: kube-exam
+description: Helm chart for Kubernetes deployment with configurable parameters.
+importance: 3
+github: https://git.slc.ar/slococo/kube-exam
+category: university
+---
+
+### Overview
+
+This project involves creating a Helm chart to simplify deploying three containers (REST API, database, React webapp) on Kubernetes. The chart allows easy customization for different needs.
+
+### Key features
+
+- **Easy deployment:** the Helm chart lets you deploy each container separately, making management simpler and more flexible.
+- **Customizable settings:** users can tweak settings like the number of API replicas, database version, and SSL setup to suit their needs.
+- **Automatic SSL setup:** choosing SSL triggers the chart to create a self-signed certificate automatically, ensuring secure communication within Kubernetes.
+- **Resource efficiency:** the chart optimizes Kubernetes resource usage, reducing the need for complex container scripts and boosting performance.

_projects/logmiddleware.md

@@ -0,0 +1,67 @@
+---
+layout: page
+title: logmiddleware
+description: Simplify the logging of incoming requests and outgoing responses.
+github: https://git.slc.ar/slococo/logmiddleware
+importance: 7
+category: personal
+---
+
+Python library designed for use with FastAPI to simplify the logging of incoming requests and outgoing responses. It includes a middleware component that adds essential information to logs, such as request and response details, and supports debugging features.
+
+## Features
+
+- **Middleware for request and response logging:** The library provides a middleware component, `RouterLoggingMiddleware`, to log incoming requests and outgoing responses. It includes features to capture request details, response information, and execution times.
+
+- **Request ID generation:** Automatically generates a unique request ID for each incoming request. If the request includes an `x-api-request-id` header, it uses that value; otherwise, it generates a new UUID.
+
+- **Debugging support:** Enables debugging of response bodies through the use of the `api_debug` flag. When enabled, the response body is included in the logs.
+
+- **JSON logging configuration:** Utilizes the `python-json-logger` library to configure JSON logging. This allows for structured and easily parsable log entries.
+
+## Installation
+
+To install the library, use the following pip command:
+
+```bash
+pip install logmiddleware
+```
+
+## Usage
+
+### Setting up middleware
+
+```python
+import logging
+from fastapi import FastAPI
+from logmiddleware import RouterLoggingMiddleware, logging_config
+
+# Configure JSON logging
+logging.config.dictConfig(logging_config)
+
+app = FastAPI()
+# Add the middleware to your FastAPI app
+app.add_middleware(
+    RouterLoggingMiddleware,
+    logger=logging.getLogger(__name__),  # Pass your logger instance
+    api_debug=True,  # Set to True to enable debugging of response bodies
+)
+```
+
+### Accessing request ID in the called function
+
+The `execute_request` method has been updated to set the `request_id` in the `request.state`. You can now access it in the called function using `request.state.request_id`. Here is an example:
+
+```python
+# ...
+
+@app.get("/example")
+async def example_route(request: Request):
+    # Accessing the request_id in the called function
+    request_id = request.state.request_id
+    return {"message": "Hello, world!", "request_id": request_id}
+```
+
+## Configuration
+
+The library relies on a logging configuration dictionary (`logging_config`) to set up JSON logging. Because of that, it includes a default logging configuration (`logging_config`), which you can import for easy setup. Ensure this configuration is properly set before adding the middleware to your FastAPI app.