Project submission

.github/workflows/gradle.yml

@@ -0,0 +1,38 @@
+name: Gradle CI
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+  pull_request:
+    branches:
+      - main
+      - develop
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Grant execute permission for Gradle wrapper
+        run: chmod +x gradlew
+
+      - name: Build with Gradle
+        run: ./gradlew clean build
+
+      - name: Run tests
+        run: ./gradlew clean test

README.md

@@ -1 +1,108 @@
-## DESM - Distributed Energy Supply Management
+# DESM - Distributed Energy System Management
+
+This is a master's degree project that was developed for the Distributed and Pervasive Systems course (A.Y 2024/25).
+
+## Project Overview
+
+The DESM (Distributed Energy Supply Management) project simulates a renewable energy supply networkRepository. A renewable energy provider generates power from sources like wind, hydro, and solar. When renewable energy alone can't meet demand, the provider relies on a networkRepository of thermal power plants to cover the shortfall.
+
+These thermal plants compete to fulfill energy requests, with the lowest bidder winning the assignment. An administration server manages the registration/removement of thermal plants and collects environmental data, such as pollutant emissions, from their sensors. This data is periodically sent to the server, which an administration client can query for statistics.
+
+![DESM Architecture](./assets/system-architecture.png)
+
+## System Architecture
+
+For sake of simplicity and ease of development, this project is structured as a Gradle multi-module project, rather than a full-fledged microservices architecture, even though it comprises distinct logical services.
+The main goal of the project is focused on inter-process communication and application of algorithms for distributed systems.
+
+### Renewable Energy Provider
+
+This entity represents the source of energy demand in the system. It initiates energy production requests when renewable sources are insufficient, transmitting this data to the Network Thermal Power Plants through MQTT.
+
+### Power Plant Network
+
+This is the core distributed component, a networkRepository of interconnected **Thermal Power Plant Peers** operating in a ring topology. Each peer is an independent node responsible for:
+
+* **Network Management**: Manage the ring structure, maintaining an up-to-date local view of the ring topology.
+* **Election Manager**: Manage the elections for the incoming energy request that have to be fulfilled using the adapted Chang-Roberts algorithm.
+* **Pollution Monitoring**: Collecting CO2 emission data and periodically transmitting this data to the Administration Server through MQTT, processed using a sliding window mechanism.
+
+### Administration Server
+A REST server that dynamically adds/removes  power plants to DESM and allows the administration client to see the currently active plants in the networkRepository and to compute statistics about pollution levels.
+
+### Administration Client
+
+A client cli that allows querying the administration server to obtain information about the currently active thermal power plants in the networkRepository and their emissions.
+
+## Setup and Run
+
+To set up and run the DESM project, follow these steps:
+
+### Prerequisites
+
+  * [**Java Development Kit**](https://www.oracle.com/it/java/technologies/downloads/): Version 17 or higher.
+  * [**MQTT Broker**](https://mosquitto.org/download/): An MQTT broker (e.g. Mosquitto, HiveMQ Community Edition) must be running and accessible. The system defaults to `tcp://localhost:1883`.
+
+### Getting Started
+
+1.  **Clone the Repository**:
+    First, clone the project repository to your local machine:
+
+    ```bash
+    git clone https://github.com/Luca-02/desm.git
+    ```
+
+2.  **Clean and Build**:
+    Navigate to the root directory of the cloned repository and perform a clean build for all subprojects:
+
+    ```bash
+    cd desm
+    ./gradlew clean build
+    ```
+
+### Running the Components
+
+Ensure your MQTT broker is running before proceeding. You should start the components in the following order: Administration Server, Administration Client, then the Power Plant Peers, and finally, the Renewable Energy Provider.
+
+1.  **Administration Server**:
+    Navigate to the `desm-server` directory and run the server application:
+
+    ```bash
+    cd .\desm-server\
+    ../gradlew run --console=plain
+    ```
+
+2.  **Administration Client**:
+    Navigate to the `desm-client` directory, and run the client application to interact with the Administration Server:
+
+    ```bash
+    cd .\desm-client\
+    ../gradlew run --console=plain
+    ```
+
+2.  **Power Plant Peers**:
+    Open a new terminal windows for each power plant peer you want to run. Navigate to the `desm-networkRepository` directory and run the application. Each instance will represent a single power plant:
+
+    ```bash
+    cd .\desm-networkRepository\
+    ../gradlew run --console=plain
+    ```
+
+4.  **Renewable Energy Provider**:
+    Navigate to the `desm-provider` directory and run the renewable energy provider application to generate energy requests:
+
+    ```bash
+    cd .\desm-provider\
+    ../gradlew run --console=plain
+    ```
+
+## Technologies Used
+
+* **Java**: Core programming language for all components.
+* **Gradle**: For project build automation.
+* **Eclipse Paho MQTT Client**: For MQTT communication.
+* **gRPC**: For RPC communication between networkRepository peers.
+* **Spring Boot**: Framework for developing the Administration Server.
+* **RESTful APIs**: For client-server communication.
+* **Gson**: For JSON serialization/deserialization across components.
+* **JUnit 5**: For unit and integration testing.

build.gradle

@@ -0,0 +1,48 @@
+allprojects {
+    group 'org.example'
+    version '1.0-SNAPSHOT'
+}
+
+subprojects {
+    apply plugin: 'java'
+    apply plugin: 'application'
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(17)
+        }
+    }
+
+    dependencies {
+        if (project.name != 'desm-core') {
+            implementation project(':desm-core')
+        }
+
+        // Testing
+        testImplementation platform('org.junit:junit-bom:5.10.0')
+        testImplementation 'org.junit.jupiter:junit-jupiter'
+        testImplementation 'org.mockito:mockito-core:5.17.0'
+        testImplementation 'org.mockito:mockito-junit-jupiter:5.17.0'
+        testImplementation 'org.mockito:mockito-inline:5.2.0'
+
+        // Lombok
+        compileOnly 'org.projectlombok:lombok:1.18.38'
+        annotationProcessor 'org.projectlombok:lombok:1.18.38'
+        testCompileOnly 'org.projectlombok:lombok:1.18.38'
+        testAnnotationProcessor 'org.projectlombok:lombok:1.18.38'
+
+        // Gson
+        implementation 'com.google.code.gson:gson:2.13.1'
+
+        // MQTT
+        implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.5'
+    }
+
+    repositories {
+        mavenCentral()
+    }
+
+    test {
+        useJUnitPlatform()
+    }
+}

desm-client/build.gradle

@@ -0,0 +1,7 @@
+application {
+    mainClassName = "org.example.desm.client.DesmClient"
+}
+
+run {
+    standardInput = System.in
+}

desm-client/src/main/java/org/example/desm/client/Client.java

@@ -0,0 +1,40 @@
+package org.example.desm.client;
+
+import org.example.desm.client.command.AvailablePowerPlant;
+import org.example.desm.client.command.QueryAverageEmission;
+
+import java.util.Scanner;
+
+public class Client {
+    public final Scanner scanner;
+    private final Menu mainMenu;
+
+    /**
+     * Constructor for the Client class.
+     */
+    public Client() {
+        this.scanner = new Scanner(System.in);
+        this.mainMenu = buildMainMenu();
+    }
+
+    /**
+     * Starts the client, displaying the menu.
+     */
+    public void start() {
+        mainMenu.show();
+        scanner.close();
+    }
+
+    /**
+     * Builds the main menu with available commands.
+     *
+     * @return The main menu
+     */
+    private Menu buildMainMenu() {
+        int i = 0;
+        Menu mainMenu = new Menu("Main Menu", scanner);
+        mainMenu.addCommand(new AvailablePowerPlant(++i, "View all power plants", scanner));
+        mainMenu.addCommand(new QueryAverageEmission(++i, "Query average emission", scanner));
+        return mainMenu;
+    }
+}

desm-client/src/main/java/org/example/desm/client/DesmClient.java

@@ -0,0 +1,7 @@
+package org.example.desm.client;
+
+public class DesmClient {
+    public static void main(String[] args) {
+        new Client().start();
+    }
+}

desm-client/src/main/java/org/example/desm/client/Menu.java

@@ -0,0 +1,72 @@
+package org.example.desm.client;
+
+import org.example.desm.client.command.Command;
+
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+/**
+ * Represents a menu that displays a list of commands and allows the user to select one to execute.
+ */
+public class Menu {
+    private final String title;
+    private final Scanner scanner;
+    private final Map<Integer, Command> commands;
+
+    /**
+     * Constructor for the Menu class.
+     *
+     * @param title   The title of the menu
+     * @param scanner The scanner for user input
+     */
+    public Menu(String title, Scanner scanner) {
+        this.title = title;
+        this.scanner = scanner;
+        this.commands = new TreeMap<>();
+    }
+
+    /**
+     * Adds a command to the menu.
+     *
+     * @param command The command to add
+     */
+    public void addCommand(Command command) {
+        commands.put(command.getId(), command);
+    }
+
+    /**
+     * Displays the menu and handles user input.
+     */
+    public void show() {
+        boolean isExiting = false;
+        while (!isExiting) {
+            System.out.println("===== " + title + " =====");
+            for (Command command : commands.values()) {
+                System.out.println(command.getId() + ". " + command.getName());
+            }
+            System.out.println("0. Exit");
+
+            System.out.print("Choose: ");
+            String input = scanner.nextLine().trim();
+
+            try {
+                int choice = Integer.parseInt(input);
+                if (choice == 0) {
+                    System.out.println("\nGoodbye!");
+                    isExiting = true;
+                    continue;
+                }
+
+                Command command = commands.get(choice);
+                if (command != null) {
+                    command.execute();
+                } else {
+                    System.out.println("Invalid option.");
+                }
+            } catch (NumberFormatException e) {
+                System.out.println("Please enter a valid number.");
+            }
+        }
+    }
+}

desm-client/src/main/java/org/example/desm/client/command/AvailablePowerPlant.java

@@ -0,0 +1,37 @@
+package org.example.desm.client.command;
+
+import org.example.desm.common.ApiClient;
+import org.example.desm.common.ResponseErrorExceptions;
+import org.example.desm.common.dto.PowerPlant;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * Custom {@link Command} to retrieve and display all available power plants.
+ * This command fetches the list of power plants from the API and prints them.
+ */
+public class AvailablePowerPlant extends Command {
+    public AvailablePowerPlant(int id, String name, Scanner scanner) {
+        super(id, name, scanner);
+    }
+
+    @Override
+    protected void command() {
+        try {
+            List<PowerPlant> plants = ApiClient.getAllPlants();
+            if (plants.isEmpty()) {
+                System.out.println("No power plants registered.");
+            } else {
+                for (PowerPlant plant : plants) {
+                    System.out.println(plant);
+                }
+            }
+        } catch (ResponseErrorExceptions e) {
+            System.err.println(e.getMessage());
+        } catch (IOException | InterruptedException e) {
+            System.err.println("Unable to retrieve plants!");
+        }
+    }
+}